View difference between Paste ID: hD5y6uRx and 4QeAEiTM

 tArgs = {...}
 
 if OneOS then
 	--running under OneOS
 	OneOS.ToolBarColour = colours.white
 	OneOS.ToolBarTextColour = colours.grey
 end
 
 local _w, _h = term.getSize()
 
 local round = function(num, idp)
 	local mult = 10^(idp or 0)
 	return math.floor(num * mult + 0.5) / mult
 end
 
 InterfaceElements = {}
 
 Drawing = {
 
 	Screen = {
 		Width = _w,
 		Height = _h
 	},
 
 	DrawCharacters = function (x, y, characters, textColour,bgColour)
 		Drawing.WriteStringToBuffer(x, y, characters, textColour, bgColour)
 	end,
 
 	DrawBlankArea = function (x, y, w, h, colour)
 		Drawing.DrawArea (x, y, w, h, " ", 1, colour)
 	end,
 
 	DrawArea = function (x, y, w, h, character, textColour, bgColour)
 		--width must be greater than 1, other wise we get a stack overflow
 		if w < 0 then
 			w = w * -1
 		elseif w == 0 then
 			w = 1
 		end
 
 		for ix = 1, w do
 			local currX = x + ix - 1
 			for iy = 1, h do
 				local currY = y + iy - 1
 				Drawing.WriteToBuffer(currX, currY, character, textColour, bgColour)
 			end
 		end
 	end,
 
 	DrawImage = function(_x,_y,tImage, w, h)
 		if tImage then
 			for y = 1, h do
 				if not tImage[y] then
 					break
 				end
 				for x = 1, w do
 					if not tImage[y][x] then
 						break
 					end
 					local bgColour = tImage[y][x]
 		            local textColour = tImage.textcol[y][x] or colours.white
 		            local char = tImage.text[y][x]
 		            Drawing.WriteToBuffer(x+_x-1, y+_y-1, char, textColour, bgColour)
 				end
 			end
 		elseif w and h then
 			Drawing.DrawBlankArea(x, y, w, h, colours.green)
 		end
 	end,
 	--using .nft
 	LoadImage = function(path)
 		local image = {
 			text = {},
 			textcol = {}
 		}
 		local fs = fs
 		if OneOS then
 			fs = OneOS.FS
 		end
 		if fs.exists(path) then
 			local _open = io.open
 			if OneOS then
 				_open = OneOS.IO.open
 			end
 	        local file = _open(path, "r")
 	        local sLine = file:read()
 	        local num = 1
 	        while sLine do
 	                table.insert(image, num, {})
 	                table.insert(image.text, num, {})
 	                table.insert(image.textcol, num, {})
 
 	                --As we're no longer 1-1, we keep track of what index to write to
 	                local writeIndex = 1
 	                --Tells us if we've hit a 30 or 31 (BG and FG respectively)- next char specifies the curr colour
 	                local bgNext, fgNext = false, false
 	                --The current background and foreground colours
 	                local currBG, currFG = nil,nil
 	                for i=1,#sLine do
 	                        local nextChar = string.sub(sLine, i, i)
 	                        if nextChar:byte() == 30 then
                                 bgNext = true
 	                        elseif nextChar:byte() == 31 then
                                 fgNext = true
 	                        elseif bgNext then
                                 currBG = Drawing.GetColour(nextChar)
                                 bgNext = false
 	                        elseif fgNext then
                                 currFG = Drawing.GetColour(nextChar)
                                 fgNext = false
 	                        else
                                 if nextChar ~= " " and currFG == nil then
                                        currFG = colours.white
                                 end
                                 image[num][writeIndex] = currBG
                                 image.textcol[num][writeIndex] = currFG
                                 image.text[num][writeIndex] = nextChar
                                 writeIndex = writeIndex + 1
 	                        end
 	                end
 	                num = num+1
 	                sLine = file:read()
 	        end
 	        file:close()
 		end
 	 	return image
 	end,
 
 	DrawCharactersCenter = function(x, y, w, h, characters, textColour,bgColour)
 		w = w or Drawing.Screen.Width
 		h = h or Drawing.Screen.Height
 		x = x or 0
 		y = y or 0
 		x = math.ceil((w - #characters) / 2) + x
 		y = math.floor(h / 2) + y
 
 		Drawing.DrawCharacters(x, y, characters, textColour, bgColour)
 	end,
 
 	GetColour = function(hex)
 		if hex == ' ' then
 			return colours.transparent
 		end
 	    local value = tonumber(hex, 16)
 	    if not value then return nil end
 	    value = math.pow(2,value)
 	    return value
 	end,
 
 	Clear = function (_colour)
 		_colour = _colour or colours.black
 		Drawing.ClearBuffer()
 		Drawing.DrawBlankArea(1, 1, Drawing.Screen.Width, Drawing.Screen.Height, _colour)
 	end,
 
 	Buffer = {},
 	BackBuffer = {},
 
 	DrawBuffer = function()
 		for y,row in pairs(Drawing.Buffer) do
 			for x,pixel in pairs(row) do
 				local shouldDraw = true
 				local hasBackBuffer = true
 				if Drawing.BackBuffer[y] == nil or Drawing.BackBuffer[y][x] == nil or #Drawing.BackBuffer[y][x] ~= 3 then
 					hasBackBuffer = false
 				end
 				if hasBackBuffer and Drawing.BackBuffer[y][x][1] == Drawing.Buffer[y][x][1] and Drawing.BackBuffer[y][x][2] == Drawing.Buffer[y][x][2] and Drawing.BackBuffer[y][x][3] == Drawing.Buffer[y][x][3] then
 					shouldDraw = false
 				end
 				if shouldDraw then
 					term.setBackgroundColour(pixel[3])
 					term.setTextColour(pixel[2])
 					term.setCursorPos(x, y)
 					term.write(pixel[1])
 				end
 			end
 		end
 		Drawing.BackBuffer = Drawing.Buffer
 		Drawing.Buffer = {}
 		term.setCursorPos(1,1)
 	end,
 
 	ClearBuffer = function()
 		Drawing.Buffer = {}
 	end,
 
 	WriteStringToBuffer = function (x, y, characters, textColour,bgColour)
 		for i = 1, #characters do
    			local character = characters:sub(i,i)
    			Drawing.WriteToBuffer(x + i - 1, y, character, textColour, bgColour)
 		end
 	end,
 
 	WriteToBuffer = function(x, y, character, textColour,bgColour)
 		x = round(x)
 		y = round(y)
 		if bgColour == colours.transparent then
 			Drawing.Buffer[y] = Drawing.Buffer[y] or {}
 			Drawing.Buffer[y][x] = Drawing.Buffer[y][x] or {"", colours.white, colours.black}
 			Drawing.Buffer[y][x][1] = character
 			Drawing.Buffer[y][x][2] = textColour
 		else
 			Drawing.Buffer[y] = Drawing.Buffer[y] or {}
 			Drawing.Buffer[y][x] = {character, textColour, bgColour}
 		end
 	end,
 }
 
 Current = {
 	Document = nil,
 	TextInput = nil,
 	CursorPos = {1,1},
 	CursorColour = colours.black,
 	Selection = {8, 36},
 	Window = nil,
 	HeaderText = '',
 	StatusText = '',
 	StatusColour = colours.grey,
 	StatusScreen = true,
 	ButtonOne = nil,
 	ButtonTwo = nil,
 	Locked = false,
 	Page = '',
 	PageControls = {}
 }
 
 isRunning = true
 
 Events = {}
 
 Button = {
 	X = 1,
 	Y = 1,
 	Width = 0,
 	Height = 0,
 	BackgroundColour = colours.lightGrey,
 	TextColour = colours.white,
 	ActiveBackgroundColour = colours.lightGrey,
 	Text = "",
 	Parent = nil,
 	_Click = nil,
 	Toggle = nil,
 
 	AbsolutePosition = function(self)
 		return self.Parent:AbsolutePosition()
 	end,
 
 	Draw = function(self)
 		local bg = self.BackgroundColour
 		local tc = self.TextColour
 		if type(bg) == 'function' then
 			bg = bg()
 		end
 
 		if self.Toggle then
 			tc = colours.white
 			bg = self.ActiveBackgroundColour
 		end
 
 		local pos = GetAbsolutePosition(self)
 		Drawing.DrawBlankArea(pos.X, pos.Y, self.Width, self.Height, bg)
 		Drawing.DrawCharactersCenter(pos.X, pos.Y, self.Width, self.Height, self.Text, tc, bg)
 	end,
 
 	Initialise = function(self, x, y, width, height, backgroundColour, parent, click, text, textColour, toggle, activeBackgroundColour)
 		local new = {}    -- the new instance
 		setmetatable( new, {__index = self} )
 		height = height or 1
 		new.Width = width or #text + 2
 		new.Height = height
 		new.Y = y
 		new.X = x
 		new.Text = text or ""
 		new.BackgroundColour = backgroundColour or colours.lightGrey
 		new.TextColour = textColour or colours.white
 		new.ActiveBackgroundColour = activeBackgroundColour or colours.lightBlue
 		new.Parent = parent
 		new._Click = click
 		new.Toggle = toggle
 		return new
 	end,
 
 	Click = function(self, side, x, y)
 		if self._Click then
 			if self:_Click(side, x, y, not self.Toggle) ~= false and self.Toggle ~= nil then
 				self.Toggle = not self.Toggle
 				Draw()
 			end
 			return true
 		else
 			return false
 		end
 	end
 }
 
 Label = {
 	X = 1,
 	Y = 1,
 	Width = 0,
 	Height = 0,
 	BackgroundColour = colours.lightGrey,
 	TextColour = colours.white,
 	Text = "",
 	Parent = nil,
 
 	AbsolutePosition = function(self)
 		return self.Parent:AbsolutePosition()
 	end,
 
 	Draw = function(self)
 		local bg = self.BackgroundColour
 		local tc = self.TextColour
 
 		if self.Toggle then
 			tc = UIColours.MenuBarActive
 			bg = self.ActiveBackgroundColour
 		end
 
 		local pos = GetAbsolutePosition(self)
 		Drawing.DrawCharacters(pos.X, pos.Y, self.Text, self.TextColour, self.BackgroundColour)
 	end,
 
 	Initialise = function(self, x, y, text, textColour, backgroundColour, parent)
 		local new = {}    -- the new instance
 		setmetatable( new, {__index = self} )
 		height = height or 1
 		new.Width = width or #text + 2
 		new.Height = height
 		new.Y = y
 		new.X = x
 		new.Text = text or ""
 		new.BackgroundColour = backgroundColour or colours.white
 		new.TextColour = textColour or colours.black
 		new.Parent = parent
 		return new
 	end,
 
 	Click = function(self, side, x, y)
 		return false
 	end
 }
 
 TextBox = {
 	X = 1,
 	Y = 1,
 	Width = 0,
 	Height = 0,
 	BackgroundColour = colours.lightGrey,
 	TextColour = colours.black,
 	Parent = nil,
 	TextInput = nil,
 	Placeholder = '',
 
 	AbsolutePosition = function(self)
 		return self.Parent:AbsolutePosition()
 	end,
 
 	Draw = function(self)
 		local pos = GetAbsolutePosition(self)
 		Drawing.DrawBlankArea(pos.X, pos.Y, self.Width, self.Height, self.BackgroundColour)
 		local text = self.TextInput.Value
 		if #tostring(text) > (self.Width - 2) then
 			text = text:sub(#text-(self.Width - 3))
 			if Current.TextInput == self.TextInput then
 				Current.CursorPos = {pos.X + 1 + self.Width-2, pos.Y}
 			end
 		else
 			if Current.TextInput == self.TextInput then
 				Current.CursorPos = {pos.X + 1 + self.TextInput.CursorPos, pos.Y}
 			end
 		end
 
 		if #tostring(text) == 0 then
 			Drawing.DrawCharacters(pos.X + 1, pos.Y, self.Placeholder, colours.lightGrey, self.BackgroundColour)
 		else
 			Drawing.DrawCharacters(pos.X + 1, pos.Y, text, self.TextColour, self.BackgroundColour)
 		end
 
 		term.setCursorBlink(true)
 
 		Current.CursorColour = self.TextColour
 	end,
 
 	Initialise = function(self, x, y, width, height, parent, text, backgroundColour, textColour, done, numerical)
 		local new = {}    -- the new instance
 		setmetatable( new, {__index = self} )
 		height = height or 1
 		new.Width = width or #text + 2
 		new.Height = height
 		new.Y = y
 		new.X = x
 		new.TextInput = TextInput:Initialise(text or '', function(key)
 			if done then
 				done(key)
 			end
 			Draw()
 		end, numerical)
 		new.BackgroundColour = backgroundColour or colours.lightGrey
 		new.TextColour = textColour or colours.black
 		new.Parent = parent
 		return new
 	end,
 
 	Click = function(self, side, x, y)
 		Current.Input = self.TextInput
 		self:Draw()
 	end
 }
 
 TextInput = {
 	Value = "",
 	Change = nil,
 	CursorPos = nil,
 	Numerical = false,
 	IsDocument = nil,
 
 	Initialise = function(self, value, change, numerical, isDocument)
 		local new = {}    -- the new instance
 		setmetatable( new, {__index = self} )
 		new.Value = tostring(value)
 		new.Change = change
 		new.CursorPos = #tostring(value)
 		new.Numerical = numerical
 		new.IsDocument = isDocument or false
 		return new
 	end,
 
 	Insert = function(self, str)
 		if self.Numerical then
 			str = tostring(tonumber(str))
 		end
 
 		local selection = OrderSelection()
 
 		if self.IsDocument and selection then
 			self.Value = string.sub(self.Value, 1, selection[1]-1) .. str .. string.sub( self.Value, selection[2]+2)
 			self.CursorPos = selection[1]
 			Current.Selection = nil
 		else
 			local _, newLineAdjust = string.gsub(self.Value:sub(1, self.CursorPos), '\n','')
 
 			self.Value = string.sub(self.Value, 1, self.CursorPos + newLineAdjust) .. str .. string.sub( self.Value, self.CursorPos + 1  + newLineAdjust)
 			self.CursorPos = self.CursorPos + 1
 		end
 
 		self.Change(key)
 	end,
 
 	Extract = function(self, remove)
 		local selection = OrderSelection()
 		if self.IsDocument and selection then
 			local _, newLineAdjust = string.gsub(self.Value:sub(selection[1], selection[2]), '\n','')
 			local str = string.sub(self.Value, selection[1], selection[2]+1+newLineAdjust)
 			if remove then
 				self.Value = string.sub(self.Value, 1, selection[1]-1) .. string.sub( self.Value, selection[2]+2+newLineAdjust)
 				self.CursorPos = selection[1] - 1
 				Current.Selection = nil
 			end
 			return str
 		end
 	end,
 
 	Char = function(self, char)
 		if char == 'nil' then
 			return
 		end
 		self:Insert(char)
 	end,
 
 	Key = function(self, key)
 		if key == keys.enter then
 			if self.IsDocument then
 				self.Value = string.sub(self.Value, 1, self.CursorPos ) .. '\n' .. string.sub( self.Value, self.CursorPos + 1 )
 				self.CursorPos = self.CursorPos + 1
 			end
 			self.Change(key)
 		elseif key == keys.left then
 			-- Left
 			if self.CursorPos > 0 then
 				local colShift = FindColours(string.sub( self.Value, self.CursorPos, self.CursorPos))
 				self.CursorPos = self.CursorPos - 1 - colShift
 				self.Change(key)
 			end
 
 		elseif key == keys.right then
 			-- Right
 			if self.CursorPos < string.len(self.Value) then
 				local colShift = FindColours(string.sub( self.Value, self.CursorPos+1, self.CursorPos+1))
 				self.CursorPos = self.CursorPos + 1 + colShift
 				self.Change(key)
 			end
 
 		elseif key == keys.backspace then
 			-- Backspace
 			if self.IsDocument and Current.Selection then
 				self:Extract(true)
 				self.Change(key)
 			elseif self.CursorPos > 0 then
 				local colShift = FindColours(string.sub( self.Value, self.CursorPos, self.CursorPos))
 				local _, newLineAdjust = string.gsub(self.Value:sub(1, self.CursorPos), '\n','')
 
 				self.Value = string.sub( self.Value, 1, self.CursorPos - 1 - colShift + newLineAdjust) .. string.sub( self.Value, self.CursorPos + 1 - colShift + newLineAdjust)
 				self.CursorPos = self.CursorPos - 1 - colShift
 				self.Change(key)
 			end
 		elseif key == keys.home then
 			-- Home
 			self.CursorPos = 0
 			self.Change(key)
 		elseif key == keys.delete then
 			if self.IsDocument and Current.Selection then
 				self:Extract(true)
 				self.Change(key)
 			elseif self.CursorPos < string.len(self.Value) then
 				self.Value = string.sub( self.Value, 1, self.CursorPos ) .. string.sub( self.Value, self.CursorPos + 2 )
 				self.Change(key)
 			end
 		elseif key == keys["end"] then
 			-- End
 			self.CursorPos = string.len(self.Value)
 			self.Change(key)
 		elseif key == keys.up and self.IsDocument then
 			-- Up
 			if Current.Document.CursorPos then
 				local page = Current.Document.Pages[Current.Document.CursorPos.Page]
 				self.CursorPos = page:GetCursorPosFromPoint(Current.Document.CursorPos.Collum + page.MarginX, Current.Document.CursorPos.Line - page.MarginY - 1 + Current.Document.ScrollBar.Scroll, true)
 				self.Change(key)
 			end
 		elseif key == keys.down and self.IsDocument then
 			-- Down
 			if Current.Document.CursorPos then
 				local page = Current.Document.Pages[Current.Document.CursorPos.Page]
 				self.CursorPos = page:GetCursorPosFromPoint(Current.Document.CursorPos.Collum + page.MarginX, Current.Document.CursorPos.Line - page.MarginY + 1 + Current.Document.ScrollBar.Scroll, true)
 				self.Change(key)
 			end
 		end
 	end
 }
 
 local Capitalise = function(str)
 	return str:sub(1, 1):upper() .. str:sub(2, -1)
 end
 
 
 local getNames = peripheral.getNames or function()
     local tResults = {}
     for n,sSide in ipairs( rs.getSides() ) do
         if peripheral.isPresent( sSide ) then
             table.insert( tResults, sSide )
             local isWireless = false
             if not pcall(function()isWireless = peripheral.call(sSide, 'isWireless') end) then
                 isWireless = true
             end
             if peripheral.getType( sSide ) == "modem" and not isWireless then
                 local tRemote = peripheral.call( sSide, "getNamesRemote" )
                 for n,sName in ipairs( tRemote ) do
                     table.insert( tResults, sName )
                 end
             end
         end
     end
     return tResults
 end
 
 Peripheral = {
     GetPeripheral = function(_type)
         for i, p in ipairs(Peripheral.GetPeripherals()) do
             if p.Type == _type then
                 return p
             end
         end
     end,
 
     Call = function(type, ...)
         local tArgs = {...}
         local p = Peripheral.GetPeripheral(type)
         peripheral.call(p.Side, unpack(tArgs))
     end,
 
     GetPeripherals = function(filterType)
         local peripherals = {}
         for i, side in ipairs(getNames()) do
             local name = peripheral.getType(side):gsub("^%l", string.upper)
             local code = string.upper(side:sub(1,1))
             if side:find('_') then
                 code = side:sub(side:find('_')+1)
             end
 
             local dupe = false
             for i, v in ipairs(peripherals) do
                 if v[1] == name .. ' ' .. code then
                     dupe = true
                 end
             end
 
             if not dupe then
                 local _type = peripheral.getType(side)
                 local isWireless = false
                 if _type == 'modem' then
                     if not pcall(function()isWireless = peripheral.call(sSide, 'isWireless') end) then
                         isWireless = true
                     end
                     if isWireless then
                         _type = 'wireless_modem'
                         name = 'W '..name
                     end
                 end
                 if not filterType or _type == filterType then
                     table.insert(peripherals, {Name = name:sub(1,8) .. ' '..code, Fullname = name .. ' ('..side:sub(1, 1):upper() .. side:sub(2, -1)..')', Side = side, Type = _type, Wireless = isWireless})
                 end
             end
         end
         return peripherals
     end,
 
     PresentNamed = function(name)
         return peripheral.isPresent(name)
     end,
 
     CallType = function(type, ...)
         local tArgs = {...}
         local p = Peripheral.GetPeripheral(type)
         return peripheral.call(p.Side, unpack(tArgs))
     end,
 
     CallNamed = function(name, ...)
         local tArgs = {...}
         return peripheral.call(name, unpack(tArgs))
     end
 }
 
 Wireless = {
 	Channels = {
 		UltimateDoorlockPing = 4210,
 		UltimateDoorlockRequest = 4211,
 		UltimateDoorlockRequestReply = 4212,
 	},
 
 	isOpen = function(channel)
 		return Peripheral.CallType('wireless_modem', 'isOpen', channel)
 	end,
 
 	Open = function(channel)
 		if not Wireless.isOpen(channel) then
 			Peripheral.CallType('wireless_modem', 'open', channel)
 		end
 	end,
 
 	close = function(channel)
 		Peripheral.CallType('wireless_modem', 'close', channel)
 	end,
 
 	closeAll = function()
 		Peripheral.CallType('wireless_modem', 'closeAll')
 	end,
 
 	transmit = function(channel, replyChannel, message)
 		Peripheral.CallType('wireless_modem', 'transmit', channel, replyChannel, textutils.serialize(message))
 	end,
 
 	Present = function()
 		if Peripheral.GetPeripheral('wireless_modem') == nil then
 			return false
 		else
 			return true
 		end
 	end,
 
 	FormatMessage = function(message, messageID, destinationID)
 		return {
 			content = textutils.serialize(message),
 			senderID = os.getComputerID(),
 			senderName = os.getComputerLabel(),
 			channel = channel,
 			replyChannel = reply,
 			messageID = messageID or math.random(10000),
 			destinationID = destinationID
 		}
 	end,
 
 	Timeout = function(func, time)
 		time = time or 1
 		parallel.waitForAny(func, function()
 			sleep(time)
 			--log('Timeout!'..time)
 		end)
 	end,
 
 	RecieveMessage = function(_channel, messageID, timeout)
 		open(_channel)
 		local done = false
 		local event, side, channel, replyChannel, message = nil
 		Timeout(function()
 			while not done do
 				event, side, channel, replyChannel, message = os.pullEvent('modem_message')
 				if channel ~= _channel then
 					event, side, channel, replyChannel, message = nil
 				else
 					message = textutils.unserialize(message)
 					message.content = textutils.unserialize(message.content)
 					if messageID and messageID ~= message.messageID or (message.destinationID ~= nil and message.destinationID ~= os.getComputerID()) then
 						event, side, channel, replyChannel, message = nil
 					else
 						done = true
 					end
 				end
 			end
 		end,
 		timeout)
 		return event, side, channel, replyChannel, message
 	end,
 
 	Initialise = function()
 		if Wireless.Present() then
 			for i, c in pairs(Wireless.Channels) do
 				Wireless.Open(c)
 			end
 		end
 	end,
 
 	HandleMessage = function(event, side, channel, replyChannel, message, distance)
 		message = textutils.unserialize(message)
 		message.content = textutils.unserialize(message.content)
 
 		if channel == Wireless.Channels.Ping then
 			if message.content == 'Ping!' then
 				SendMessage(replyChannel, 'Pong!', nil, message.messageID)
 			end
 		elseif message.destinationID ~= nil and message.destinationID ~= os.getComputerID() then
 		elseif Wireless.Responder then
 			Wireless.Responder(event, side, channel, replyChannel, message, distance)
 		end
 	end,
 
 	SendMessage = function(channel, message, reply, messageID, destinationID)
 		reply = reply or channel + 1
 		Wireless.Open(channel)
 		Wireless.Open(reply)
 		local _message = Wireless.FormatMessage(message, messageID, destinationID)
 		Wireless.transmit(channel, reply, _message)
 		return _message
 	end,
 
 	Ping = function()
 		local message = SendMessage(Channels.Ping, 'Ping!', Channels.PingReply)
 		RecieveMessage(Channels.PingReply, message.messageID)
 	end
 }
 
 function GetAbsolutePosition(object)
 	local obj = object
 	local i = 0
 	local x = 1
 	local y = 1
 	while true do
 		x = x + obj.X - 1
 		y = y + obj.Y - 1
 
 		if not obj.Parent then
 			return {X = x, Y = y}
 		end
 
 		obj = obj.Parent
 
 		if i > 32 then
 			return {X = 1, Y = 1}
 		end
 
 		i = i + 1
 	end
 
 end
 
 function Draw()
 	Drawing.Clear(colours.white)
 
 	if Current.StatusScreen then
 		Drawing.DrawCharactersCenter(1, -2, nil, nil, Current.HeaderText, colours.blue, colours.white)
 		Drawing.DrawCharactersCenter(1, -1, nil, nil, 'by oeed', colours.lightGrey, colours.white)
 		Drawing.DrawCharactersCenter(1, 1, nil, nil, Current.StatusText, Current.StatusColour, colours.white)
 	end
 
 	if Current.ButtonOne then
 		Current.ButtonOne:Draw()
 	end
 
 	if Current.ButtonTwo then
 		Current.ButtonTwo:Draw()
 	end
 
 	for i, v in ipairs(Current.PageControls) do
 		v:Draw()
 	end
 
 	Drawing.DrawBuffer()
 
 	if Current.TextInput and Current.CursorPos and not Current.Menu and not(Current.Window and Current.Document and Current.TextInput == Current.Document.TextInput) and Current.CursorPos[2] > 1 then
 		term.setCursorPos(Current.CursorPos[1], Current.CursorPos[2])
 		term.setCursorBlink(true)
 		term.setTextColour(Current.CursorColour)
 	else
 		term.setCursorBlink(false)
 	end
 end
 MainDraw = Draw
 
 function GenerateFingerprint()
     local str = ""
     for _ = 1, 256 do
         local char = math.random(32, 126)
         --if char == 96 then char = math.random(32, 95) end
         str = str .. string.char(char)
     end
     return str
 end
 
 function MakeFingerprint()
 	local h = fs.open('.fingerprint', 'w')
 	if h then
 		h.write(GenerateFingerprint())
 	end
 	h.close()
 	Current.Fingerprint = str
 end
 
 local drawTimer = nil
 function SetText(header, status, colour, isReset)
 	if header then
 		Current.HeaderText = header
 	end
 	if status then
 		Current.StatusText = status
 	end
 	if colour then
 		Current.StatusColour = colour
 	end
 	Draw()
 	if not isReset then
 		statusResetTimer = os.startTimer(2)
 	end
 end
 
 function ResetStatus()
 	if pocket then
 		if Current.Locked then
 			SetText('Ultimate Door Lock', 'Add Wireless Modem to PDA', colours.red, true)
 		else
 			SetText('Ultimate Door Lock', 'Ready', colours.grey, true)
 		end
 	else
 		if Current.Locked then
 			SetText('Ultimate Door Lock', ' Attach a Wireless Modem then reboot', colours.red, true)
 		else
 			SetText('Ultimate Door Lock', 'Ready', colours.grey, true)
 		end
 	end
 end
 
 function ResetPage()
 	Wireless.Responder = function()end
 	pingTimer = nil
 	Current.PageControls = nil
 	Current.StatusScreen = false
 	Current.ButtonOne = nil
 	Current.ButtonTwo = nil
 	Current.PageControls = {}
 	CloseDoor()
 end
 
 function PocketInitialise()
 	Current.ButtonOne = Button:Initialise(Drawing.Screen.Width - 6, Drawing.Screen.Height - 1, nil, nil, nil, nil, Quit, 'Quit', colours.black)
 	if not Wireless.Present() then
 		Current.Locked = true
 		ResetStatus()
 		return
 	end
 	Wireless.Initialise()
 	ResetStatus()
 	if fs.exists('.fingerprint') then
 		local h = fs.open('.fingerprint', 'r')
 		if h then
 			Current.Fingerprint = h.readAll()
 		else
 			MakeFingerprint()
 		end
 		h.close()
 	else
 		MakeFingerprint()
 	end
 
 	Wireless.Responder = function(event, side, channel, replyChannel, message, distance)
 		if channel == Wireless.Channels.UltimateDoorlockPing then
 			Wireless.SendMessage(Wireless.Channels.UltimateDoorlockRequest, Current.Fingerprint, Wireless.Channels.UltimateDoorlockRequestReply, nil, message.senderID)
 		elseif channel == Wireless.Channels.UltimateDoorlockRequestReply then
 			if message.content == true then
 				SetText(nil, 'Opening Door', colours.green)
 			else
 				SetText(nil, ' Access Denied', colours.red)
 			end
 		end
 	end
 end
 
 function FingerprintIsOnWhitelist(fingerprint)
 	if Current.Settings.Whitelist then
 		for i, f in ipairs(Current.Settings.Whitelist) do
 			if f == fingerprint then
 				return true
 			end
 		end
 	end
 	return false
 end
 
 function SaveSettings()
 	Current.Settings = Current.Settings or {}
 	local h = fs.open('.settings', 'w')
 	if h then
 		h.write(textutils.serialize(Current.Settings))
 	end
 	h.close()
 end
 
 local closeDoorTimer = nil
 function OpenDoor()
 	if Current.Settings and Current.Settings.RedstoneSide then
 		SetText(nil, 'Opening Door', colours.green)
 		redstone.setOutput(Current.Settings.RedstoneSide, true)
 		closeDoorTimer = os.startTimer(0.6)
 	end
 end
 
 function CloseDoor()
 	if Current.Settings and Current.Settings.RedstoneSide then
 		if redstone.getOutput(Current.Settings.RedstoneSide) then
 			SetText(nil, 'Closing Door', colours.orange)
 			redstone.setOutput(Current.Settings.RedstoneSide, false)
 		end
 	end
 end
 
 DefaultSettings = {
 	Whitelist = {},
 	RedstoneSide = 'back',
 	Distance = 10
 }
 
 function RegisterPDA(event, drive)
 	if disk.hasData(drive) then
 		local _fs = fs
 		if OneOS then
 			_fs = OneOS.FS
 		end
 		local path = disk.getMountPath(drive)
 		local addStartup = true
 		if _fs.exists(path..'/System/') then
 			path = path..'/System/'
 			addStartup = false
 		end
 		local fingerprint = nil
 		if _fs.exists(path..'/.fingerprint') then
 			local h = _fs.open(path..'/.fingerprint', 'r')
 			if h then
 				local str = h.readAll()
 				if #str == 256 then
 					fingerprint = str
 				end
 			end
 			h.close()
 		end
 		if not fingerprint then
 			fingerprint = GenerateFingerprint()
 			local h = _fs.open(path..'/.fingerprint', 'w')
 			h.write(fingerprint)
 			h.close()
 			if addStartup then
 				local h = fs.open(shell.getRunningProgram(), 'r')
 				local startup = h.readAll()
 				h.close()
 				local h = _fs.open(path..'/startup', 'w')
 				h.write(startup)
 				h.close()
 			end
 		end
 		if not FingerprintIsOnWhitelist(fingerprint) then
 			table.insert(Current.Settings.Whitelist, fingerprint)
 			SaveSettings()
 		end
 		disk.eject(drive)
 		SetText(nil, 'Registered Pocket Computer', colours.green)
 	end
 end
 
 function HostSetup()
 	ResetPage()
 	Current.Page = 'HostSetup'
 	Current.ButtonTwo = Button:Initialise(Drawing.Screen.Width - 6, Drawing.Screen.Height - 1, nil, nil, nil, nil, HostStatusPage, 'Save', colours.black)
 	if not Current.Settings then
 		Current.Settings = DefaultSettings
 	end
 
 	local sideButtons = {}
 	local function resetSideToggle(self)
 		for i, v in ipairs(sideButtons) do
 			if v.Toggle ~= nil then
 				v.Toggle = false
 			end
 		end
 		Current.Settings.RedstoneSide = self.Text:lower()
 		SaveSettings()
 	end
 
 	table.insert(Current.PageControls, Label:Initialise(2, 2, 'Redstone Side'))
 	sideButtons = {
 		Button:Initialise(2, 4, nil, nil, nil, nil, resetSideToggle, 'Back', colours.black, false, colours.green),
 		Button:Initialise(9, 4, nil, nil, nil, nil, resetSideToggle, 'Front', colours.black, false, colours.green),
 		Button:Initialise(2, 6, nil, nil, nil, nil, resetSideToggle, 'Left', colours.black, false, colours.green),
 		Button:Initialise(9, 6, nil, nil, nil, nil, resetSideToggle, 'Right', colours.black, false, colours.green),
 		Button:Initialise(2, 8, nil, nil, nil, nil, resetSideToggle, 'Top', colours.black, false, colours.green),
 		Button:Initialise(8, 8, nil, nil, nil, nil, resetSideToggle, 'Bottom', colours.black, false, colours.green)
 	}
   	for i, v in ipairs(sideButtons) do
   		if v.Text:lower() == Current.Settings.RedstoneSide then
   			v.Toggle = true
   		end
   		table.insert(Current.PageControls, v)
   	end
 
 	local distanceButtons = {}
 	local function resetDistanceToggle(self)
 		for i, v in ipairs(distanceButtons) do
 			if v.Toggle ~= nil then
 				v.Toggle = false
 			end
 		end
   		if self.Text == 'Small' then
   			Current.Settings.Distance = 5
   		elseif self.Text == 'Normal' then
   			Current.Settings.Distance = 10
   		elseif self.Text == 'Far' then
   			Current.Settings.Distance = 15
   		end
 		SaveSettings()
 	end
 
 	table.insert(Current.PageControls, Label:Initialise(23, 2, 'Opening Distance'))
 	distanceButtons = {
 		Button:Initialise(23, 4, nil, nil, nil, nil, resetDistanceToggle, 'Small', colours.black, false, colours.green),
 		Button:Initialise(31, 4, nil, nil, nil, nil, resetDistanceToggle, 'Normal', colours.black, false, colours.green),
 		Button:Initialise(40, 4, nil, nil, nil, nil, resetDistanceToggle, 'Far', colours.black, false, colours.green)
 	}
   	for i, v in ipairs(distanceButtons) do
   		if v.Text == 'Small' and Current.Settings.Distance == 5 then
   			v.Toggle = true
   		elseif v.Text == 'Normal' and Current.Settings.Distance == 10 then
   			v.Toggle = true
   		elseif v.Text == 'Far' and Current.Settings.Distance == 15 then
   			v.Toggle = true
   		end
   		table.insert(Current.PageControls, v)
   	end
 
 	table.insert(Current.PageControls, Label:Initialise(2, 10, 'Registered PDAs: '..#Current.Settings.Whitelist))
 	table.insert(Current.PageControls, Button:Initialise(2, 12, nil, nil, nil, nil, function()Current.Settings.Whitelist = {}HostSetup()end, 'Unregister All', colours.black))
 
 
   	table.insert(Current.PageControls, Label:Initialise(23, 6, 'Help', colours.black))
   	local helpLines = {
   		Label:Initialise(23, 8, 'To register a new PDA simply', colours.black),
   		Label:Initialise(23, 9, 'place a Disk Drive next to', colours.black),
   		Label:Initialise(23, 10, 'the computer, then put the', colours.black),
   		Label:Initialise(23, 11, 'PDA in the Drive, it will', colours.black),
   		Label:Initialise(23, 12, 'register automatically. If', colours.black),
   		Label:Initialise(23, 13, 'it worked it will eject.', colours.black),
   		Label:Initialise(23, 15, 'Make sure you hide this', colours.red),
   		Label:Initialise(23, 16, 'computer away from the', colours.red),
   		Label:Initialise(23, 17, 'door! (other people)', colours.red)
   	}
   	for i, v in ipairs(helpLines) do
   		table.insert(Current.PageControls, v)
   	end
 
 
 	table.insert(Current.PageControls, Button:Initialise(2, 14, nil, nil, nil, nil, function()
 	  	for i = 1, 6 do
 	  		helpLines[i].TextColour = colours.green
 	  	end
 	end, 'Register New PDA', colours.black))
 
 end
 
 function HostStatusPage()
 	ResetPage()
 	Current.Page = 'HostStatus'
 	Current.StatusScreen = true
 	Current.ButtonOne = Button:Initialise(Drawing.Screen.Width - 6, Drawing.Screen.Height - 1, nil, nil, nil, nil, Quit, 'Quit', colours.black)
 	Current.ButtonTwo = Button:Initialise(2, Drawing.Screen.Height - 1, nil, nil, nil, nil, HostSetup, 'Settings/Help', colours.black)
 
 	Wireless.Responder = function(event, side, channel, replyChannel, message, distance)
 		if channel == Wireless.Channels.UltimateDoorlockRequest and distance < Current.Settings.Distance then
 			if FingerprintIsOnWhitelist(message.content) then
 				OpenDoor()
 				Wireless.SendMessage(Wireless.Channels.UltimateDoorlockRequestReply, true)
 			else
 				Wireless.SendMessage(Wireless.Channels.UltimateDoorlockRequestReply, false)
 			end
 		end
 	end
 
 	PingPocketComputers()
 end
 
 function HostInitialise()
 	if not Wireless.Present() then
 		Current.Locked = true
 		Current.ButtonOne = Button:Initialise(Drawing.Screen.Width - 6, Drawing.Screen.Height - 1, nil, nil, nil, nil, Quit, 'Quit', colours.black)
 		Current.ButtonTwo = Button:Initialise(2, Drawing.Screen.Height - 1, nil, nil, nil, nil, function()os.reboot()end, 'Reboot', colours.black)
 		ResetStatus()
 		return
 	end
 	Wireless.Initialise()
 	ResetStatus()
 	if fs.exists('.settings') then
 		local h = fs.open('.settings', 'r')
 		if h then
 			Current.Settings = textutils.unserialize(h.readAll())
 		end
 		h.close()
 		HostStatusPage()
 	else
 		HostSetup()
 	end
 	if OneOS then
 		OneOS.CanClose = function()
 			CloseDoor()
 			return true
 		end
 	end
 end
 
 local pingTimer = nil
 function PingPocketComputers()
 	Wireless.SendMessage(Wireless.Channels.UltimateDoorlockPing, 'Ping!', Wireless.Channels.UltimateDoorlockRequest)
 	pingTimer = os.startTimer(0.5)
 end
 
 function Initialise(arg)
 	EventRegister('mouse_click', TryClick)
 	EventRegister('mouse_drag', function(event, side, x, y)TryClick(event, side, x, y, true)end)
 	EventRegister('mouse_scroll', Scroll)
 	EventRegister('key', HandleKey)
 	EventRegister('char', HandleKey)
 	EventRegister('timer', Timer)
 	EventRegister('terminate', function(event) if Close() then error( "Terminated", 0 ) end end)
 	EventRegister('modem_message', Wireless.HandleMessage)
 	EventRegister('disk', RegisterPDA)
 
 	if OneOS then
 		OneOS.RequestRunAtStartup()
 	end
 
 	if pocket then
 		PocketInitialise()
 	else
 		HostInitialise()
 	end
 
 
 	Draw()
 
 	EventHandler()
 end
 
 function Timer(event, timer)
 	if timer == pingTimer then
 		PingPocketComputers()
 	elseif timer == closeDoorTimer then
 		CloseDoor()
 	elseif timer == statusResetTimer then
 		ResetStatus()
 	end
 end
 
 local ignoreNextChar = false
 function HandleKey(...)
 	local args = {...}
 	local event = args[1]
 	local keychar = args[2]
 	--[[
 																							--Mac left command character
 	if event == 'key' and keychar == keys.leftCtrl or keychar == keys.rightCtrl or keychar == 219 then
 		isControlPushed = true
 		controlPushedTimer = os.startTimer(0.5)
 	elseif isControlPushed then
 		if event == 'key' then
 			if CheckKeyboardShortcut(keychar) then
 				isControlPushed = false
 				ignoreNextChar = true
 			end
 		end
 	elseif ignoreNextChar then
 		ignoreNextChar = false
 	elseif Current.TextInput then
 		if event == 'char' then
 			Current.TextInput:Char(keychar)
 		elseif event == 'key' then
 			Current.TextInput:Key(keychar)
 		end
 	end
 	]]--
 end
 
 --[[
 	Check if the given object falls under the click coordinates
 ]]--
 function CheckClick(object, x, y)
 	if object.X <= x and object.Y <= y and object.X + object.Width > x and object.Y + object.Height > y then
 		return true
 	end
 end
 
 --[[
 	Attempt to clicka given object
 ]]--
 function DoClick(object, side, x, y, drag)
 	local obj = GetAbsolutePosition(object)
 	obj.Width = object.Width
 	obj.Height = object.Height
 	if object and CheckClick(obj, x, y) then
 		return object:Click(side, x - object.X + 1, y - object.Y + 1, drag)
 	end
 end
 
 --[[
 	Try to click at the given coordinates
 ]]--
 function TryClick(event, side, x, y, drag)
 	if Current.ButtonOne then
 		if DoClick(Current.ButtonOne, side, x, y, drag) then
 			Draw()
 			return
 		end
 	end
 
 	if Current.ButtonTwo then
 		if DoClick(Current.ButtonTwo, side, x, y, drag) then
 			Draw()
 			return
 		end
 	end
 
 	for i, v in ipairs(Current.PageControls) do
 		if DoClick(v, side, x, y, drag) then
 			Draw()
 			return
 		end
 	end
 
 	Draw()
 end
 
 function Scroll(event, direction, x, y)
 	if Current.Window and Current.Window.OpenButton then
 		Current.Document.Scroll = Current.Document.Scroll + direction
 		if Current.Window.Scroll < 0 then
 			Current.Window.Scroll = 0
 		elseif Current.Window.Scroll > Current.Window.MaxScroll then
 			Current.Window.Scroll = Current.Window.MaxScroll
 		end
 		Draw()
 	elseif Current.ScrollBar then
 		if Current.ScrollBar:DoScroll(direction*2) then
 			Draw()
 		end
 	end
 end
 
 --[[
 	Registers functions to run on certain events
 ]]--
 function EventRegister(event, func)
 	if not Events[event] then
 		Events[event] = {}
 	end
 
 	table.insert(Events[event], func)
 end
 
 --[[
 	The main loop event handler, runs registered event functinos
 ]]--
 function EventHandler()
 	while isRunning do
 		local event, arg1, arg2, arg3, arg4, arg5, arg6 = os.pullEventRaw()
 		if Events[event] then
 			for i, e in ipairs(Events[event]) do
 				e(event, arg1, arg2, arg3, arg4, arg5, arg6)
 			end
 		end
 	end
 end
 
 function Quit()
 	isRunning = false
 	term.setCursorPos(1,1)
 	term.setBackgroundColour(colours.black)
 	term.setTextColour(colours.white)
 	term.clear()
 	if OneOS then
 		OneOS.Close()
 	end
 end
 
 if not term.current then -- if not 1.6
 	print('Because it requires pocket computers, Ultimate Door Lock requires ComputerCraft 1.6. Please update to 1.6 to use Ultimate Door Lock.')
 elseif not (OneOS and pocket) and term.isColor and term.isColor() then
 	-- If the program crashes close the door and reboot
 	local _, err = pcall(Initialise)
 	if err then
 		CloseDoor()
 		term.setCursorPos(1,1)
 		term.setBackgroundColour(colours.black)
 		term.setTextColour(colours.white)
 		term.clear()
 		print('Ultimate Door Lock has crashed')
 		print('To maintain security, the computer will reboot.')
 		print('If you are seeing this alot try turning off all Pocket Computers or reinstall.')
 		print()
 		print('Error:')
 		printError(err)
 		sleep(5)
 		os.reboot()
 	end
 elseif OneOS and pocket then
 	term.setCursorPos(1,3)
 	term.setBackgroundColour(colours.white)
 	term.setTextColour(colours.blue)
 	term.clear()
 	print('OneOS already acts as a door key. Simply place your PDA in the door\'s disk drive to register it.')
 	print()
 	print('To setup a door, run this program on an advanced computer (non-pocket).')
 	print()
 	print('Click anywhere to quit')
 	os.pullEvent('mouse_click')
 	Quit()
 else
 	print('Ultimate Door Lock requires an advanced (gold) computer or pocket computer.')
 end