View difference between Paste ID: eL3a8Uu2 and udDhEHeV

 --[[
-		NPaintPro
+                NPaintPro
-		By NitrogenFingers
+                By NitrogenFingers
 ]]--
 
 --The screen size
 local w,h = term.getSize()
 --Whether or not the program is currently waiting on user input
 local inMenu = false
 --Whether or not a drop down menu is active
 local inDropDown = false
 --Whether or not animation tools are enabled (use -a to turn them on)
 local animated = false
 --Whether or not the text tools are enabled (use -t to turn them on)
 local textual = false
 --Whether or not "blueprint" display mode is on
 local blueprint = false
 --Whether or not the "layer" display is on
 local layerDisplay = false
 --Whether or not the interface is presently hidden
 local interfaceHidden = false
 --Whether or not the "direction" display is on
 local printDirection = false
 --The tool/mode npaintpro is currently in. Default is "paint"
 --For a list of modes, check out the help file
 local state = "paint"
 --Whether or not the program is presently running
 local isRunning = true
 --The rednet address of the 3D printer, if one has been attached
 local printer = nil
 
 --The list of every frame, containing every image in the picture/animation
 --Note: nfp files always have the picture at frame 1
 local frames = { }
 --How many frames are currently in the given animation.
 local frameCount = 1
 --The Colour Picker column
 local column = {}
 --The offset of visible colours in the picker column, if the screen cannot fit all 16
 local columnoffset = 0
 --The currently selected left and right colours
 local lSel,rSel = colours.white,nil
 --The amount of scrolling on the X and Y axis
 local sx,sy = 0,0
 --The alpha channel colour
 --Change this to change default canvas colour
 local alphaC = colours.black
 --The currently selected frame. Default is 1
 local sFrame = 1
 --The contents of the image buffer- contains contents, width and height
 local buffer = nil
 --The position, width and height of the selection rectangle
 local selectrect = nil
 
 --Whether or not text tools are enabled for this document
 local textEnabled = false
 --The X and Y positions of the text cursor
 local textCurX, textCurY = 1,1
 
 --The currently calculated required materials
 local requiredMaterials = {}
 --Whether or not required materials are being displayed in the pallette
 local requirementsDisplayed = false
 --A list of the rednet ID's all in-range printers located
 local printerList = { }
 --A list of the names of all in-range printers located. Same as the printerList in reference
 local printerNames = { }
 --The selected printer
 local selectedPrinter = 1
 --The X,Y,Z and facing of the printer
---The animation state of the selection rectangle and image buffer
+
 --The form of layering used
 local layering = "up"
 
 --The animation state of the selection rectangle and image buffer
 local rectblink = 0
 --The ID for the timer
 local recttimer = nil
 --The radius of the brush tool
 local brushsize = 3
 --Whether or not "record" mode is activated (animation mode only)
 local record = false
 --The time between each frame when in play mode (animation mode only)
 local animtime = 0.3
 
 --The current "cursor position" in text mode
 local cursorTexX,cursorTexY = 1,1
 
 --A list of hexidecimal conversions from numbers to hex digits
 local hexnums = { [10] = "a", [11] = "b", [12] = "c", [13] = "d", [14] = "e" , [15] = "f" }
 --The NPaintPro logo (divine, isn't it?)
 local logo = {
 "fcc              3   339";
 " fcc          9333    33";
 "  fcc        933 333  33";
 "   fcc       933  33  33";
 "    fcc      933   33 33";
 "     c88     333   93333";
 "     888     333    9333";
-	"0000000";
+
-	"0088880";
+
-	"0888870";
+
-	"07777f0";
+
-	"0ffff00";
+        "0000000";
-	"0000000";
+        "0088880";
         "0888870";
         "07777f0";
-	"0000000";
+        "0ffff00";
-	"000fff0";
+        "0000000";
-	"00777f0";
+
-	"0888700";
+
-	"0888000";
+        "0000000";
-	"0000000";
+        "000fff0";
         "00777f0";
         "0888700";
         "0888000";
         "0000000";
-local ddModes = { { "paint", "brush", "pippette", "flood", "move", "clear", "select", name = "painting" }, { "alpha to left", "alpha to right", name = "display" }, "help", { "print", "save", "exit", name = "file" }, name = "menu" }
+
 --The available menu options in the ctrl menu
 local mChoices = {"Save","Exit"}
 --The available modes from the dropdown menu- tables indicate submenus (include a name!)
 local ddModes = { { "paint", "brush", "pippette", "flood", "move", "clear", "select", name = "painting" }, { "alpha to left", "alpha to right", "hide interface", name = "display" }, "help", { "print", "save", "exit", name = "file" }, name = "menu" }
-	[1] = {
+
-		name = "Paint Mode",
+
-		key = nil,
+
-		animonly = false,
+
-		textonly = false,
+        [1] = {
-		message = "The default mode for NPaintPro, for painting pixels."
+                name = "Paint Mode",
-		.." Controls here that are not overridden will apply for all other modes. Leaving a mode by selecting that mode "
+                key = nil,
-		.." again will always send the user back to paint mode.",
+                animonly = false,
-		controls = {
+                textonly = false,
-			{ "Arrow keys", "Scroll the canvas" },
+                message = "The default mode for NPaintPro, for painting pixels."
-			{ "Left Click", "Paint/select left colour" },
+                .." Controls here that are not overridden will apply for all other modes. Leaving a mode by selecting that mode "
-			{ "Right Click", "Paint/select right colour" },
+                .." again will always send the user back to paint mode.",
-			{ "Z Key", "Clear image on screen" },
+                controls = {
-			{ "Tab Key", "Hide selection rectangle if visible" },
+                        { "Arrow keys", "Scroll the canvas" },
-			{ "Q Key", "Set alpha mask to left colour" },
+                        { "Left Click", "Paint/select left colour" },
-			{ "W Key", "Set alpha mask to right colour" },
+                        { "Right Click", "Paint/select right colour" },
-			{ "Number Keys", "Swich between frames 1-9" },
+                        { "Z Key", "Clear image on screen" },
-			{ "</> keys", "Move to the next/last frame" },
+                        { "Tab Key", "Hide selection rectangle if visible" },
-			{ "R Key", "Removes every frame after the current frame"}
+                        { "Q Key", "Set alpha mask to left colour" },
-		}
+                        { "W Key", "Set alpha mask to right colour" },
-	},
+                        { "Number Keys", "Swich between frames 1-9" },
-	[2] = {
+                        { "</> keys", "Move to the next/last frame" },
-		name = "Brush Mode",
+                        { "R Key", "Removes every frame after the current frame"}
-		key = "b",
+                }
-		animonly = false,
+        },
-		textonly = false,
+        [2] = {
-		message = "Brush mode allows painting a circular area of variable diameter rather than a single pixel, working in "..
+                name = "Brush Mode",
-		"the exact same way as paint mode in all other regards.",
+                key = "b",
-		controls = {
+                animonly = false,
-			{ "Left Click", "Paints a brush blob with the left colour" },
+                textonly = false,
-			{ "Right Click", "Paints a brush blob with the right colour" },
+                message = "Brush mode allows painting a circular area of variable diameter rather than a single pixel, working in "..
-			{ "Number Keys", "Changes the radius of the brush blob from 2-9" }
+                "the exact same way as paint mode in all other regards.",
-		}
+                controls = {
-	},
+                        { "Left Click", "Paints a brush blob with the left colour" },
-	[3] = {
+                        { "Right Click", "Paints a brush blob with the right colour" },
-		name = "Pippette Mode",
+                        { "Number Keys", "Changes the radius of the brush blob from 2-9" }
-		key = "p",
+                }
-		animonly = false,
+        },
-		textonly = false,
+        [3] = {
-		message = "Pippette mode allows the user to click the canvas and set the colour clicked to the left or right "..
+                name = "Pippette Mode",
-		"selected colour, for later painting.",
+                key = "p",
-		controls = {
+                animonly = false,
-			{ "Left Click", "Sets clicked colour to the left selected colour" },
+                textonly = false,
-			{ "Right Click", "Sets clicked colour to the right selected colour" }
+                message = "Pippette mode allows the user to click the canvas and set the colour clicked to the left or right "..
-		}
+                "selected colour, for later painting.",
-	},
+                controls = {
-	[4] = {
+                        { "Left Click", "Sets clicked colour to the left selected colour" },
-		name = "Move Mode",
+                        { "Right Click", "Sets clicked colour to the right selected colour" }
-		key = "m",
+                }
-		animonly = false,
+        },
-		textonly = false,
+        [4] = {
-		message = "Mode mode allows the moving of the entire image on the screen. This is especially useful for justifying"..
+                name = "Move Mode",
-		" the image to the top-left for animations or game assets.",
+                key = "m",
-		controls = {
+                animonly = false,
-			{ "Left/Right Click", "Moves top-left corner of image to selected square" },
+                textonly = false,
-			{ "Arrow keys", "Moves image one pixel in any direction" }
+                message = "Mode mode allows the moving of the entire image on the screen. This is especially useful for justifying"..
-		}
+                " the image to the top-left for animations or game assets.",
-	},
+                controls = {
-	[5] = {
+                        { "Left/Right Click", "Moves top-left corner of image to selected square" },
-		name = "Flood Mode",
+                        { "Arrow keys", "Moves image one pixel in any direction" }
-		key = "f",
+                }
-		animonly = false,
+        },
-		textonly = false,
+        [5] = {
-		message = "Flood mode allows the changing of an area of a given colour to that of the selected colour. "..
+                name = "Flood Mode",
-		"The tool uses a flood4 algorithm and will not fill diagonally. Transparency cannot be flood filled.",
+                key = "f",
-		controls = {
+                animonly = false,
-			{ "Left Click", "Flood fills selected area to left colour" },
+                textonly = false,
-			{ "Right Click", "Flood fills selected area to right colour" }
+                message = "Flood mode allows the changing of an area of a given colour to that of the selected colour. "..
-		}
+                "The tool uses a flood4 algorithm and will not fill diagonally. Transparency cannot be flood filled.",
-	},
+                controls = {
-	[6] = {
+                        { "Left Click", "Flood fills selected area to left colour" },
-		name = "Select Mode",
+                        { "Right Click", "Flood fills selected area to right colour" }
-		key = "s",
+                }
-		animonly = false,
+        },
-		textonly = false,
+        [6] = {
-		message = "Select mode allows the creation and use of the selection rectangle, to highlight specific areas on "..
+                name = "Select Mode",
-		"the screen and perform operations on the selected area of the image. The selection rectangle can contain an "..
+                key = "s",
-		"image on the clipboard- if it does, the image will flash inside the rectangle, and the rectangle edges will "..
+                animonly = false,
-		"be light grey instead of dark grey.",
+                textonly = false,
-		controls = {
+                message = "Select mode allows the creation and use of the selection rectangle, to highlight specific areas on "..
-			{ "C Key", "Copy: Moves selection into the clipboard" },
+                "the screen and perform operations on the selected area of the image. The selection rectangle can contain an "..
-			{ "X Key", "Cut: Clears canvas under the rectangle, and moves it into the clipboard" },
+                "image on the clipboard- if it does, the image will flash inside the rectangle, and the rectangle edges will "..
-			{ "V Key", "Paste: Copys clipboard to the canvas" },
+                "be light grey instead of dark grey.",
-			{ "Z Key", "Clears clipboard" },
+                controls = {
-			{ "Left Click", "Moves top-left corner of rectangle to selected pixel" },
+                        { "C Key", "Copy: Moves selection into the clipboard" },
-			{ "Right Click", "Opens selection menu" },
+                        { "X Key", "Cut: Clears canvas under the rectangle, and moves it into the clipboard" },
-			{ "Arrow Keys", "Moves rectangle one pixel in any direction" }
+                        { "V Key", "Paste: Copys clipboard to the canvas" },
-		}
+                        { "Z Key", "Clears clipboard" },
-	},
+                        { "Left Click", "Moves top-left corner of rectangle to selected pixel" },
-	[7] = {
+                        { "Right Click", "Opens selection menu" },
-		name = "Corner Select Mode",
+                        { "Arrow Keys", "Moves rectangle one pixel in any direction" }
-		key = nil,
+                }
-		animonly = false,
+        },
-		textonly = false,
+        [7] = {
-		message = "If a selection rectangle isn't visible, this mode is selected automatically. It allows the "..
+                name = "Corner Select Mode",
-		"defining of the corners of the rectangle- one the top-left and bottom-right corners have been defined, "..
+                key = nil,
-		"NPaintPro switches to selection mode. Note rectangle must be at least 2 pixels wide and high.",
+                animonly = false,
-		controls = {
+                textonly = false,
-			{ "Left/Right Click", "Defines a corner of the selection rectangle" }
+                message = "If a selection rectangle isn't visible, this mode is selected automatically. It allows the "..
-		}
+                "defining of the corners of the rectangle- one the top-left and bottom-right corners have been defined, "..
-	},
+                "NPaintPro switches to selection mode. Note rectangle must be at least 2 pixels wide and high.",
-	[8] = {
+                controls = {
-		name = "Play Mode",
+                        { "Left/Right Click", "Defines a corner of the selection rectangle" }
-		key = "space",
+                }
-		animonly = true,
+        },
-		textonly = false,
+        [8] = {
-		message = "Play mode will loop through each frame in your animation at a constant rate. Editing tools are "..
+                name = "Play Mode",
-		"locked in this mode, and the coordinate display will turn green to indicate it is on.",
+                key = "space",
-		controls = {
+                animonly = true,
-			{ "</> Keys", "Increases/Decreases speed of the animation" },
+                textonly = false,
-			{ "Space Bar", "Returns to paint mode" }
+                message = "Play mode will loop through each frame in your animation at a constant rate. Editing tools are "..
-		}
+                "locked in this mode, and the coordinate display will turn green to indicate it is on.",
-	},
+                controls = {
-	[9] = {
+                        { "</> Keys", "Increases/Decreases speed of the animation" },
-		name = "Record Mode",
+                        { "Space Bar", "Returns to paint mode" }
-		key = "\\",
+                }
-		animonly = true,
+        },
-		textonly = false,
+        [9] = {
-		message = "Record mode is not a true mode, but influences how other modes work. Changes made that modify the "..
+                name = "Record Mode",
-		"canvas in record mode will affect ALL frames in the animation. The coordinates will turn red to indicate that "..
+                key = "\\",
-		"record mode is on.",
+                animonly = true,
-		controls = {
+                textonly = false,
-			{ "", "Affects:" },
+                message = "Record mode is not a true mode, but influences how other modes work. Changes made that modify the "..
-			{ "- Paint Mode", "" },
+                "canvas in record mode will affect ALL frames in the animation. The coordinates will turn red to indicate that "..
-			{ "- Brush Mode", "" },
+                "record mode is on.",
-			{ "- Cut and Paste in Select Mode", ""},
+                controls = {
-			{ "- Move Mode", ""}
+                        { "", "Affects:" },
-		}
+                        { "- Paint Mode", "" },
-	},
+                        { "- Brush Mode", "" },
-	[10] = {
+                        { "- Cut and Paste in Select Mode", ""},
-		name = "Help Mode",
+                        { "- Move Mode", ""}
-		key = "h",
+                }
-		animonly = false,
+        },
-		textonly = false,
+		[10] = {
-		message = "Displays this help screen. Clicking on options will display help on that topic. Clicking out of the screen"..
+				name = "Hide Interface",
-		" will leave this mode.",
+				key = "~",
-		controls = {
+				animonly = false,
-			{ "Left/Right Click", "Displays a topic/Leaves the mode" }
+				textonly = false,
-		}
+				message = "Hides the sidebar and colour picker so only the image is visible."..
-	},
+				" The program can be started with the interface hidden using the -d command line option."..
-	[11] = {
+				" When hidden, if a file is animated it will automatically go to play mode.\n"..
-		name = "File Mode",
+				"Note that all other input is locked until the display is revealed again in this"..
-		key = nil,
+				" mode.",
-		animonly = false,
+				controls = {
-		textonly = false,
+                    { "</> Keys", "Increases/Decreases speed of the animation" },
-		message = "Clicking on the mode display at the bottom of the screen will open the options menu. Here you can"..
+					{ "~ Key", "Shows interface"}
-		" activate all of the modes in the program with a simple mouse click. Pressing left control will open up the"..
+				}
-		" file menu automatically.",
+		},
-		controls = {
+        [11] = {
-			{ "leftCtrl", "Opens the file menu" },
+                name = "Help Mode",
-			{ "leftAlt", "Opens the paint menu" }
+                key = "h",
-		}
+                animonly = false,
-	},
+                textonly = false,
-	[12] = {
+                message = "Displays this help screen. Clicking on options will display help on that topic. Clicking out of the screen"..
-		name = "Text Mode",
+                " will leave this mode.",
-		key = "t",
+                controls = {
-		animonly = false,
+                        { "Left/Right Click", "Displays a topic/Leaves the mode" }
-		textonly = true,
+                }
-		message = "In this mode, the user is able to type letters onto the document for display. The left colour "..
+        },
-		"pallette value determines what colour the text will be, and the right determines what colour the background "..
+        [12] = {
-		"will be (set either to nil to keep the same colours as already there).",
+                name = "File Mode",
-		controls = {
+                key = nil,
-			{ "Backspace", "Deletes the character on the previous line" },
+                animonly = false,
-			{ "Arrow Keys", "Moves the cursor in any direction" },
+                textonly = false,
-			{ "Left Click", "Moves the cursor to beneath the mouse cursor" }
+                message = "Clicking on the mode display at the bottom of the screen will open the options menu. Here you can"..
-		}
+                " activate all of the modes in the program with a simple mouse click. Pressing left control will open up the"..
-	},
+                " file menu automatically.",
-	[13] = {
+                controls = {
-		name = "Textpaint Mode",
+                        { "leftCtrl", "Opens the file menu" },
-		key = "y",
+                        { "leftAlt", "Opens the paint menu" }
-		animonly = false,
+                }
-		textonly = true,
+        },
-		message = "Allows the user to paint any text on screen to the desired colour with the mouse. If affects the text colour"..
+        [13] = {
-		" values rather than the background values, but operates identically to paint mode in all other regards.",
+                name = "Text Mode",
-		controls = {
+                key = "t",
-			{ "Left Click", "Paints the text with the left colour" },
+                animonly = false,
-			{ "Right Click", "Paints the text with the right colour" }
+                textonly = true,
-		}
+                message = "In this mode, the user is able to type letters onto the document for display. The left colour "..
-	},
+                "pallette value determines what colour the text will be, and the right determines what colour the background "..
-	[14] = {
+                "will be (set either to nil to keep the same colours as already there).",
-		name = "About NPaintPro",
+                controls = {
-		keys = nil,
+                        { "Backspace", "Deletes the character on the previous line" },
-		animonly = false,
+                        { "Arrow Keys", "Moves the cursor in any direction" },
-		textonly = false,
+                        { "Left Click", "Moves the cursor to beneath the mouse cursor" }
-		message = "NPaintPro: The feature-bloated paint program for ComputerCraft by Nitrogen Fingers.",
+                }
-		controls = {
+        },
-			{ "Testers:", " "},
+        [14] = {
-			{ " ", "Faubiguy"},
+                name = "Textpaint Mode",
-			{ " ", "TheOriginalBIT"}
+                key = "y",
-		}
+                animonly = false,
-	}
+                textonly = true,
                 message = "Allows the user to paint any text on screen to the desired colour with the mouse. If affects the text colour"..
                 " values rather than the background values, but operates identically to paint mode in all other regards.",
                 controls = {
                         { "Left Click", "Paints the text with the left colour" },
                         { "Right Click", "Paints the text with the right colour" }
                 }
         },
-			Section:  Helpers
+        [15] = {
                 name = "About NPaintPro",
                 keys = nil,
                 animonly = false,
                 textonly = false,
-	Returns:string A string conversion of the colour
+                message = "NPaintPro: The feature-bloated paint program for ComputerCraft by Nitrogen Fingers.",
                 controls = {
                         { "Testers:", " "},
-	if not colour or not tonumber(colour) then
+                        { " ", "Faubiguy"},
-		return " "
+                        { " ", "TheOriginalBIT"}
                 }
-	local value = math.log(colour)/math.log(2)
+        }
-	if value > 9 then
+
-		value = hexnums[value]
+
 local toplim,botlim,leflim,riglim = nil,nil,nil,nil
-	return value
+
 local sPath = nil
 
 
-	Params: hex:?string = the hex digit to be converted
+--Screen Size Parameters- decided dynamically further down the program
-	Returns:string A colour value corresponding to the hex, or nil if the character is invalid
+--Whether or not the help screen is available
 local helpAvailable = true
 --Whether or not the main menu is available
-	local value = tonumber(hex, 16)
+local mainAvailable = true
-	if not value then return nil end
+--Whether or not selection box dropdowns are available
-	value = math.pow(2,value)
+local boxdropAvailable = true
-	return value
+--Whether or not a manual file descriptor option is available (part of the title)
 local filemakerAvailable = true
 
 --[[
-	These values are assigned to the "lim" parameters for access by other methods
+                        Section:  Helpers
-	Params: forAllFrames:bool = True if all frames should be used to find bounds, otherwise false or nil
+
 
 --[[Converts a colour parameter into a single-digit hex coordinate for the colour
     Params: colour:int = The colour to be converted
-	local f,l = sFrame,sFrame
+        Returns:string A string conversion of the colour
-	if forAllFrames == true then f,l = 1,framecount end
+
 local function getHexOf(colour)
-	toplim,botlim,leflim,riglim = nil,nil,nil,nil
+        if not colour or not tonumber(colour) then
-	for locf = f,l do
+                return " "
-		for y,_ in pairs(frames[locf]) do
+        end
-			if type(y) == "number" then
+        local value = math.log(colour)/math.log(2)
-				for x,_ in pairs(frames[locf][y]) do
+        if value > 9 then
-					if frames[locf][y][x] ~= nil then
+                value = hexnums[value]
-						if leflim == nil or x < leflim then leflim = x end
+        end
-						if toplim == nil or y < toplim then toplim = y end
+        return value
-						if riglim == nil or x > riglim then riglim = x end
+
-						if botlim == nil or y > botlim then botlim = y end
+
-					end
+
         Params: hex:?string = the hex digit to be converted
         Returns:string A colour value corresponding to the hex, or nil if the character is invalid
 ]]--
 local function getColourOf(hex)
         local value = tonumber(hex, 16)
-	--There is just... no easier way to do this. It's horrible, but necessary
+        if not value then return nil end
-	if textEnabled then
+        value = math.pow(2,value)
-		for locf = f,l do
+        return value
-			for y,_ in pairs(frames[locf].text) do
+
-				for x,_ in pairs(frames[locf].text[y]) do
+
-					if frames[locf].text[y][x] ~= nil then
+--[[Finds the largest width and height of the text in a given menu. Should conform to the format
-						if leflim == nil or x < leflim then leflim = x end
+	of all standard menus (number indexed values and a 'name' field).
-						if toplim == nil or y < toplim then toplim = y end
+	This is done recursively. It's just easier that way.
-						if riglim == nil or x > riglim then riglim = x end
+	Params: menu:table = the table being tested for the max width and height
-						if botlim == nil or y > botlim then botlim = y end
+	Returns:number,number = the max width and height of the text or names of any menu or submenu.
-					end
+
 local function findMaxWH(menu)
 	local wmax,hmax = #menu.name, #menu
-			for y,_ in pairs(frames[locf].textcol) do
+	for _,entry in pairs(menu) do
-				for x,_ in pairs(frames[locf].textcol[y]) do
+		if type(entry) == "table" then
-					if frames[locf].textcol[y][x] ~= nil then
+			local nw,nh = findMaxWH(entry)
-						if leflim == nil or x < leflim then leflim = x end
+			wmax = math.max(wmax,nw)
-						if toplim == nil or y < toplim then toplim = y end
+			hmax = math.max(hmax,nh)
-						if riglim == nil or x > riglim then riglim = x end
+
-						if botlim == nil or y > botlim then botlim = y end
+			wmax = math.max(wmax,#entry)
-					end
+
 	end
 	return wmax,hmax
 end
 
 --[[Determines what services are available depending on the size of the screen. Certain features
 	may be disabled with screen real estate does not allow for it.
 	Params: none
 	Returns:nil
-	Returns:table A complete list of how much of each material is required.
+
 local function determineAvailableServices()
 	--Help files were designed to fit a 'standard' CC screen, of 51 x 19. The height of the screen
-	updateImageLims(animated)
+	--needs to match the number of available options plus white space, but for consistency with
-	requiredMaterials = {}
+	--the files themselves, a natural size of 51 is required for the screen width as well.
-	for i=1,16 do
+	if w < 51 or h < #helpTopics+3 then helpAvailable = false end
-		requiredMaterials[i] = 0
+	if not helpAvailable then table.remove(ddModes,3) end
 	--These hard-coded values mirror the drawLogo values, with extra consideration for the
 	--additional menu options
-	if not toplim then return end
+	if h < 14 or w < 24 then filemakerAvailable = false end
 
-	for i=1,#frames do
+	--Menus can't cover the picker and need 2 spaces for branches. 4 whitespace on X total.
-		for y = toplim, botlim do
+	--Menus need a title and can't eclipse the footer. 2 whitespace on Y total.
-			for x = leflim, riglim do
+	local wmin,hmin = findMaxWH(ddModes)
-				if type(frames[i][y][x]) == "number" then
+	if w < wmin+4 or h < hmin+2 then mainAvailable = false end
-					requiredMaterials[math.log10(frames[i][y][x])/math.log10(2) + 1] =
+	wmin,hmin = findMaxWH(srModes)
-						requiredMaterials[math.log10(frames[i][y][x])/math.log10(2) + 1] + 1
+	if w < wmin+4 or h < hmin+2 then boxdropAvailable = false end
-				end
+
 
 --[[Finds the biggest and smallest bounds of the image- the outside points beyond which pixels do not appear
         These values are assigned to the "lim" parameters for access by other methods
         Params: forAllFrames:bool = True if all frames should be used to find bounds, otherwise false or nil
         Returns:nil
 ]]--
 local function updateImageLims(forAllFrames)
-	Params: nil
+        local f,l = sFrame,sFrame
         if forAllFrames == true then f,l = 1,framecount end
 
         toplim,botlim,leflim,riglim = nil,nil,nil,nil
-	if id == recttimer then
+        for locf = f,l do
-		recttimer = os.startTimer(0.5)
+                for y,_ in pairs(frames[locf]) do
-		rectblink = (rectblink % 2) + 1
+                        if type(y) == "number" then
                                 for x,_ in pairs(frames[locf][y]) do
                                         if frames[locf][y][x] ~= nil then
                                                 if leflim == nil or x < leflim then leflim = x end
                                                 if toplim == nil or y < toplim then toplim = y end
-	Params: nil
+                                                if riglim == nil or x > riglim then riglim = x end
-	Returns:string A message regarding the state of the application
+                                                if botlim == nil or y > botlim then botlim = y end
                                         end
                                 end
-	local msg = " "..string.upper(string.sub(state, 1, 1))..string.sub(state, 2, #state).." mode"
+                        end
-	if state == "brush" then msg = msg..", size="..brushsize end
+                end
-	return msg
+        end
 
         --There is just... no easier way to do this. It's horrible, but necessary
         if textEnabled then
-	system timer ticking.
+                for locf = f,l do
-	Params: timeout:number how long before the event times out
+                        for y,_ in pairs(frames[locf].text) do
-	Returns:number the id of the sender
+                                for x,_ in pairs(frames[locf].text[y]) do
-		   :number the message send
+                                        if frames[locf].text[y][x] ~= nil then
                                                 if leflim == nil or x < leflim then leflim = x end
                                                 if toplim == nil or y < toplim then toplim = y end
-	local timerID
+                                                if riglim == nil or x > riglim then riglim = x end
-	if timeout then timerID = os.startTimer(timeout) end
+                                                if botlim == nil or y > botlim then botlim = y end
                                         end
-	local id,key,msg = nil,nil
+                                end
                         end
-		id,key,msg = os.pullEvent()
+                        for y,_ in pairs(frames[locf].textcol) do
                                 for x,_ in pairs(frames[locf].textcol[y]) do
-		if id == "timer" then
+                                        if frames[locf].textcol[y][x] ~= nil then
-			if key == timerID then return
+                                                if leflim == nil or x < leflim then leflim = x end
-			else updateTimer(key) end
+                                                if toplim == nil or y < toplim then toplim = y end
                                                 if riglim == nil or x > riglim then riglim = x end
-		if id == "rednet_message" then
+                                                if botlim == nil or y > botlim then botlim = y end
-			return key,msg
+                                        end
                                 end
                         end
                 end
         end
 end
-	Params: image:table = the image to display
+
-			xinit:number = the x position of the top-left corner of the image
+
-			yinit:number = the y position of the top-left corner of the image
+        Params: none
-			alpha:number = the color to display for the alpha channel. Default is white.
+        Returns:table A complete list of how much of each material is required.
 ]]--
 function calculateMaterials()
         updateImageLims(animated)
-	if not alpha then alpha = 1 end
+        requiredMaterials = {}
-	for y=1,#image do
+        for i=1,16 do
-		for x=1,#image[y] do
+                requiredMaterials[i] = 0
-			term.setCursorPos(xinit + x-1, yinit + y-1)
+        end
-			local col = getColourOf(string.sub(image[y], x, x))
+
-			if not col then col = alpha end
+        if not toplim then return end
-			term.setBackgroundColour(col)
+
-			term.write(" ")
+        for i=1,#frames do
                 for y = toplim, botlim do
                         for x = leflim, riglim do
                                 if type(frames[i][y][x]) == "number" then
                                         requiredMaterials[math.log10(frames[i][y][x])/math.log10(2) + 1] =
                                                 requiredMaterials[math.log10(frames[i][y][x])/math.log10(2) + 1] + 1
-			Section: Loading
+                                end
-]]--
+                        end
                 end
         end
-	Params: path:string = The path in which the file is located
+
 
 
 --[[Updates the rectangle blink timer. Should be called anywhere events are captured, along with a timer capture.
-	sFrame = 1
+        Params: nil
-	frames[sFrame] = { }
+        Returns:nil
-	if fs.exists(path) then
+
-		local file = io.open(path, "r" )
+
-		local sLine = file:read()
+        if id == recttimer then
-		local num = 1
+                recttimer = os.startTimer(0.5)
-		while sLine do
+                rectblink = (rectblink % 2) + 1
-			table.insert(frames[sFrame], num, {})
+        end
-			for i=1,#sLine do
+
-				frames[sFrame][num][i] = getColourOf(string.sub(sLine,i,i))
+
 --[[Constructs a message based on the state currently selected
-			num = num+1
+        Params: nil
-			sLine = file:read()
+        Returns:string A message regarding the state of the application
 ]]--
-		file:close()
+
         local msg = " "..string.upper(string.sub(state, 1, 1))..string.sub(state, 2, #state).." mode"
         if state == "brush" then msg = msg..", size="..brushsize end
         return msg
 end
-	Params: path:string = The path in which the file is located
+
 --[[Calls the rednet_message event, but also looks for timer events to keep then
         system timer ticking.
         Params: timeout:number how long before the event times out
-	sFrame = 1
+        Returns:number the id of the sender
-	frames[sFrame] = { }
+                   :number the message send
-	frames[sFrame].text = { }
+
-	frames[sFrame].textcol = { }
+
         local timerID
-	if fs.exists(path) then
+        if timeout then timerID = os.startTimer(timeout) end
-		local file = io.open(path, "r")
+
-		local sLine = file:read()
+        local id,key,msg = nil,nil
-		local num = 1
+        while true do
-		while sLine do
+                id,key,msg = os.pullEvent()
-			table.insert(frames[sFrame], num, {})
+
-			table.insert(frames[sFrame].text, num, {})
+                if id == "timer" then
-			table.insert(frames[sFrame].textcol, num, {})
+                        if key == timerID then return
                         else updateTimer(key) end
-			--As we're no longer 1-1, we keep track of what index to write to
+                end
-			local writeIndex = 1
+                if id == "rednet_message" then
-			--Tells us if we've hit a 30 or 31 (BG and FG respectively)- next char specifies the curr colour
+                        return key,msg
-			local bgNext, fgNext = false, false
+                end
-			--The current background and foreground colours
+        end
-			local currBG, currFG = nil,nil
+
-			term.setCursorPos(1,1)
+
-			for i=1,#sLine do
+
-				local nextChar = string.sub(sLine, i, i)
+        Params: image:table = the image to display
-				if nextChar:byte() == 30 then
+                        xinit:number = the x position of the top-left corner of the image
-					bgNext = true
+                        yinit:number = the y position of the top-left corner of the image
-				elseif nextChar:byte() == 31 then
+                        alpha:number = the color to display for the alpha channel. Default is white.
-					fgNext = true
+        Returns:nil
-				elseif bgNext then
+
-					currBG = getColourOf(nextChar)
+
-					bgNext = false
+        if not alpha then alpha = 1 end
-				elseif fgNext then
+        for y=1,#image do
-					currFG = getColourOf(nextChar)
+                for x=1,#image[y] do
-					fgNext = false
+                        term.setCursorPos(xinit + x-1, yinit + y-1)
                         local col = getColourOf(string.sub(image[y], x, x))
-					if nextChar ~= " " and currFG == nil then
+                        if not col then col = alpha end
-						currFG = colours.white
+                        term.setBackgroundColour(col)
-					end
+                        term.write(" ")
-					frames[sFrame][num][writeIndex] = currBG
+                end
-					frames[sFrame].textcol[num][writeIndex] = currFG
+        end
-					frames[sFrame].text[num][writeIndex] = nextChar
+
-					writeIndex = writeIndex + 1
+
 --[[
                         Section: Loading
-			num = num+1
+
-			sLine = file:read()
+
 --[[Loads a non-animted paint file into the program
-		file:close()
+        Params: path:string = The path in which the file is located
         Returns:nil
 ]]--
 local function loadNFP(path)
         sFrame = 1
-	Params: path:string = The path in which the file is located
+        frames[sFrame] = { }
         if fs.exists(path) then
                 local file = io.open(path, "r" )
                 local sLine = file:read()
-	frames[sFrame] = { }
+                local num = 1
-	if fs.exists(path) then
+                while sLine do
-		local file = io.open(path, "r" )
+                        table.insert(frames[sFrame], num, {})
-		local sLine = file:read()
+                        for i=1,#sLine do
-		local num = 1
+                                frames[sFrame][num][i] = getColourOf(string.sub(sLine,i,i))
-		while sLine do
+                        end
-			table.insert(frames[sFrame], num, {})
+                        num = num+1
-			if sLine == "~" then
+                        sLine = file:read()
-				sFrame = sFrame + 1
+                end
-				frames[sFrame] = { }
+                file:close()
-				num = 1
+        end
 end
-				for i=1,#sLine do
+
-					frames[sFrame][num][i] = getColourOf(string.sub(sLine,i,i))
+
         Params: path:string = The path in which the file is located
-				num = num+1
+        Returns:nil
 ]]--
-			sLine = file:read()
+
         sFrame = 1
-		file:close()
+        frames[sFrame] = { }
         frames[sFrame].text = { }
-	framecount = sFrame
+        frames[sFrame].textcol = { }
-	sFrame = 1
+
         if fs.exists(path) then
                 local file = io.open(path, "r")
                 local sLine = file:read()
-	Params: path:string = The path to save the file to
+                local num = 1
                 while sLine do
                         table.insert(frames[sFrame], num, {})
                         table.insert(frames[sFrame].text, num, {})
-	local sDir = string.sub(sPath, 1, #sPath - #fs.getName(sPath))
+                        table.insert(frames[sFrame].textcol, num, {})
-	if not fs.exists(sDir) then
+
-		fs.makeDir(sDir)
+                        --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 file = io.open(path, "w")
+                        local bgNext, fgNext = false, false
-	updateImageLims(false)
+                        --The current background and foreground colours
-	if not toplim then
+                        local currBG, currFG = nil,nil
-		file:close()
+                        term.setCursorPos(1,1)
                         for i=1,#sLine do
                                 local nextChar = string.sub(sLine, i, i)
-	for y=1,botlim do
+                                if nextChar:byte() == 30 then
-		local line = ""
+                                        bgNext = true
-		if frames[sFrame][y] then
+                                elseif nextChar:byte() == 31 then
-			for x=1,riglim do
+                                        fgNext = true
-				line = line..getHexOf(frames[sFrame][y][x])
+                                elseif bgNext then
                                         currBG = getColourOf(nextChar)
                                         bgNext = false
-		file:write(line.."\n")
+                                elseif fgNext then
                                         currFG = getColourOf(nextChar)
-	file:close()
+                                        fgNext = false
                                 else
                                         if nextChar ~= " " and currFG == nil then
                                                 currFG = colours.white
-	Params: path:string = The path to save the file to
+                                        end
                                         frames[sFrame][num][writeIndex] = currBG
                                         frames[sFrame].textcol[num][writeIndex] = currFG
                                         frames[sFrame].text[num][writeIndex] = nextChar
-	local sDir = string.sub(sPath, 1, #sPath - #fs.getName(sPath))
+                                        writeIndex = writeIndex + 1
-	if not fs.exists(sDir) then
+                                end
-		fs.makeDir(sDir)
+                        end
                         num = num+1
                         sLine = file:read()
-	local file = io.open(path, "w")
+                end
-	updateImageLims(false)
+                file:close()
-	if not toplim then
+        end
-		file:close()
+
 
 --[[Loads an animated paint file into the program
-	for y=1,botlim do
+        Params: path:string = The path in which the file is located
-		local line = ""
+        Returns:nil
-		local currBG, currFG = nil,nil
+
-		for x=1,riglim do
+
-			if frames[sFrame][y] and frames[sFrame][y][x] ~= currBG then
+        frames[sFrame] = { }
-				line = line..string.char(30)..getHexOf(frames[sFrame][y][x])
+        if fs.exists(path) then
-				currBG = frames[sFrame][y][x]
+                local file = io.open(path, "r" )
                 local sLine = file:read()
-			if frames[sFrame].textcol[y] and frames[sFrame].textcol[y][x] ~= currFG then
+                local num = 1
-				line = line..string.char(31)..getHexOf(frames[sFrame].textcol[y][x])
+                while sLine do
-				currFG = frames[sFrame].textcol[y][x]
+                        table.insert(frames[sFrame], num, {})
                         if sLine == "~" then
-			if frames[sFrame].text[y] then
+                                sFrame = sFrame + 1
-				local char = frames[sFrame].text[y][x]
+                                frames[sFrame] = { }
-				if not char then char = " " end
+                                num = 1
-				line = line..char
+                        else
                                 for i=1,#sLine do
                                         frames[sFrame][num][i] = getColourOf(string.sub(sLine,i,i))
-		file:write(line.."\n")
+                                end
                                 num = num+1
-	file:close()
+                        end
                         sLine = file:read()
                 end
                 file:close()
-	Params: path:string = The path to save the file to
+        end
         framecount = sFrame
         sFrame = 1
 end
-	local sDir = string.sub(sPath, 1, #sPath - #fs.getName(sPath))
+
-	if not fs.exists(sDir) then
+
-		fs.makeDir(sDir)
+        Params: path:string = The path to save the file to
         Returns:nil
 ]]--
-	local file = io.open(path, "w")
+
-	updateImageLims(true)
+        local sDir = string.sub(sPath, 1, #sPath - #fs.getName(sPath))
-	if not toplim then
+        if not fs.exists(sDir) then
-		file:close()
+                fs.makeDir(sDir)
         end
 
-	for i=1,#frames do
+        local file = io.open(path, "w")
-		for y=1,botlim do
+        updateImageLims(false)
-			local line = ""
+        if not toplim then
-			if frames[i][y] then
+                file:close()
-				for x=1,riglim do
+                return
-					line = line..getHexOf(frames[i][y][x])
+        end
         for y=1,botlim do
                 local line = ""
-			file:write(line.."\n")
+                if frames[sFrame][y] then
                         for x=1,riglim do
-		if i < #frames then file:write("~\n") end
+                                line = line..getHexOf(frames[sFrame][y][x])
                         end
-	file:close()
+                end
                 file:write(line.."\n")
         end
         file:close()
 end
 
 --[[Saves a text-paint file to the specified path
         Params: path:string = The path to save the file to
         Returns:nil
-	if textEnabled then
+
-		loadNFT(sPath)
+
-		table.insert(ddModes, 2, { "text", "textpaint", name = "text"})
+        local sDir = string.sub(sPath, 1, #sPath - #fs.getName(sPath))
-	elseif animated then
+        if not fs.exists(sDir) then
-		loadNFA(sPath)
+                fs.makeDir(sDir)
-		table.insert(ddModes, #ddModes, { "record", "play", name = "anim" })
+        end
-		table.insert(ddModes, #ddModes, { "go to", "remove", name = "frames"})
+
-		table.insert(ddModes[2], #ddModes[2], "blueprint on")
+        local file = io.open(path, "w")
-		table.insert(ddModes[2], #ddModes[2], "layers on")
+        updateImageLims(false)
-	else
+        if not toplim then
-		loadNFP(sPath)
+                file:close()
-		table.insert(ddModes[2], #ddModes[2], "blueprint on")
+                return
         end
         for y=1,botlim do
-	for i=0,15 do
+                local line = ""
-		table.insert(column, math.pow(2,i))
+                local currBG, currFG = nil,nil
                 for x=1,riglim do
                         if frames[sFrame][y] and frames[sFrame][y][x] ~= currBG then
                                 line = line..string.char(30)..getHexOf(frames[sFrame][y][x])
                                 currBG = frames[sFrame][y][x]
-			Section: Drawing
+                        end
                         if frames[sFrame].textcol[y] and frames[sFrame].textcol[y][x] ~= currFG then
                                 line = line..string.char(31)..getHexOf(frames[sFrame].textcol[y][x])
                                 currFG = frames[sFrame].textcol[y][x]
                         end
-	actual program.
+                        if frames[sFrame].text[y] then
                                 local char = frames[sFrame].text[y][x]
                                 if not char then char = " " end
                                 line = line..char
                         end
-	term.setBackgroundColour(colours.white)
+                end
-	term.clear()
+                file:write(line.."\n")
-	drawPictureTable(logo, w/2 - #logo[1]/2, h/2 - #logo/2, colours.white)
+        end
-	term.setBackgroundColour(colours.white)
+        file:close()
-	term.setTextColour(colours.black)
+
-	local msg = "NPaintPro"
+
-	term.setCursorPos(w/2 - #msg/2, h-3)
+
-	term.write(msg)
+        Params: path:string = The path to save the file to
-	msg = "By NitrogenFingers"
+        Returns:nil
-	term.setCursorPos(w/2 - #msg/2, h-2)
+
-	term.write(msg)
+
         local sDir = string.sub(sPath, 1, #sPath - #fs.getName(sPath))
-	os.pullEvent()
+        if not fs.exists(sDir) then
                 fs.makeDir(sDir)
         end
 
-	rectanlge if any of these things are present.
+        local file = io.open(path, "w")
         updateImageLims(true)
         if not toplim then
                 file:close()
                 return
-	--We have to readjust the position of the canvas if we're printing
+        end
-	turtlechar = "@"
+        for i=1,#frames do
-	if state == "active print" then
+                for y=1,botlim do
-		if layering == "up" then
+                        local line = ""
-			if py >= 1 and py <= #frames then
+                        if frames[i][y] then
-				sFrame = py
+                                for x=1,riglim do
                                         line = line..getHexOf(frames[i][y][x])
-			if pz < sy then sy = pz
+                                end
-			elseif pz > sy + h - 1 then sy = pz + h - 1 end
+                        end
-			if px < sx then sx = px
+                        file:write(line.."\n")
-			elseif px > sx + w - 2 then sx = px + w - 2 end
+                end
                 if i < #frames then file:write("~\n") end
-			if pz >= 1 and pz <= #frames then
+        end
-				sFrame = pz
+        file:close()
 end
 
-			if py < sy then sy = py
+--[[Runs a special pre-program dialogue to determine the filename and filepath. Done if
-			elseif py > sy + h - 1 then sy = py + h - 1 end
+	there's room, and a file name hasn't been specified
-			if px < sx then sx = px
+
-			elseif px > sx + w - 2 then sx = px + w - 2 end
+	Returns:bool= true if file is created; false otherwise
 ]]--
 local function runFileMaker()
-		if pfx == 1 then turtlechar = ">"
+	local newFName = ""
-		elseif pfx == -1 then turtlechar = "<"
+	local fileType = 1
-		elseif pfz == 1 then turtlechar = "V"
+	if animated then fileType = 2
-		elseif pfz == -1 then turtlechar = "^"
+	elseif textEnabled then fileType = 3 end
 
 	local tlx,tly = math.floor(w/2 - #logo[1]/2), math.floor(h/2 + #logo/2 + 1)
 
-	--Picture next
+	--This is done on top of the logo, so it backpedals a bit.
-	local topLayer, botLayer
+	term.setCursorPos(tlx, tly)
-	if layerDisplay then
+
-		topLayer = sFrame
+	term.write("Name: ")
-		botLayer = 1
+	term.setCursorPos(tlx, tly + 1)
 	term.clearLine()
-		topLayer,botLayer = sFrame,sFrame
+	term.write("Filetype:   Sprite")
 	term.setCursorPos(tlx + 12, tly + 2)
 	term.write("Animation")
-	for currframe = botLayer,topLayer,1 do
+	term.setCursorPos(tlx + 12, tly + 3)
-		for y=sy+1,sy+h-1 do
+	term.write("Text")
-			if frames[currframe][y] then
+
-				for x=sx+1,sx+w-2 do
+
-					term.setCursorPos(x-sx,y-sy)
+		term.setCursorPos(tlx + 6, tly)
-					if frames[currframe][y][x] then
+
-						term.setBackgroundColour(frames[currframe][y][x])
+
-						if textEnabled and frames[currframe].textcol[y][x] and frames[currframe].text[y][x] then
+		term.write(newFName..string.rep(" ", 15-#newFName))
-							term.setTextColour(frames[currframe].textcol[y][x])
+		term.setBackgroundColour(colours.white)
-							term.write(frames[currframe].text[y][x])
+
-						else
+		local extension = ".nfp"
-							term.write(" ")
+		if fileType == 2 then extension = ".nfa"
-						end
+		elseif fileType == 3 then extension = ".nft" end
-					else
+		term.write(extension)
-						tileExists = false
+
-						for i=currframe-1,botLayer,-1 do
+
-							if frames[i][y][x] then
+
-								tileExists = true
+		for i=1,3 do
-								break
+			term.setCursorPos(tlx + 24, tly + i)
 			if i==fileType then term.write("X")
-						end
+			else term.write(" ") end
-
+
-						if not tileExists then
+
-							if blueprint then
+		local fPath = shell.resolve(newFName..extension)
-								term.setBackgroundColour(colours.blue)
+		term.setCursorPos(tlx, tly + 3)
-								term.setTextColour(colours.white)
+		local fileValid = true
-								if x == sx+1 and y % 4 == 1 then
+		if (fs.exists(fPath) and fs.isDir(fPath)) or newFName == "" then
-									term.write(""..((y/4) % 10))
+			term.setBackgroundColour(colours.white)
-								elseif y == sy + 1 and x % 4 == 1 then
+
-									term.write(""..((x/4) % 10))
+			term.write("Invalid ")
-								elseif x % 2 == 1 and y % 2 == 1 then
+			fileValid = false
-									term.write("+")
+		elseif fs.exists(fPath) then
-								elseif x % 2 == 1 then
+
-									term.write("|")
+
-								elseif y % 2 == 1 then
+			term.write(" Edit  ")
-									term.write("-")
+
-								else
+
-									term.write(" ")
+
 			term.write(" Create ")
-							else
+
-								term.setBackgroundColour(alphaC)
+
-								if textEnabled and frames[currframe].textcol[y][x] and frames[currframe].text[y][x] then
+
-									term.setTextColour(frames[currframe].textcol[y][x])
+		term.setCursorPos(tlx + 6 + #newFName, tly)
-									term.write(frames[currframe].text[y][x])
+		term.setCursorBlink(true)
-								else
+
-									term.write(" ")
+
 		if id == "key" then
 			if p1 == keys.backspace and #newFName > 0 then
-						end
+				newFName = string.sub(newFName, 1, #newFName-1)
-					end
+			elseif p1 == keys.enter and fileValid then
 				sPath = fPath
 				return true
-				for x=sx+1,sx+w-2 do
+
-					term.setCursorPos(x-sx,y-sy)
+		elseif id == "char" and p1 ~= "." and p1 ~= " " and #newFName < 15 then
-
+			newFName = newFName..p1
-					tileExists = false
+
-					for i=currframe-1,botLayer,-1 do
+			--The option boxes. Man, hardcoding is ugly...
-						if frames[i][y] and frames[i][y][x] then
+			if p2 == tlx + 24 then
-							tileExists = true
+				for i=1,3 do
-							break
+					if p3 == tly+i then fileType = i end
-						end
+
-					end
+
-
+			if p3 == tly + 3 and p2 >= tlx and p2 <= tlx + 8 and fileValid then
-					if not tileExists then
+				sPath = fPath
-						if blueprint then
+				return true
-							term.setBackgroundColour(colours.blue)
+
-							term.setTextColour(colours.white)
+
-							if x == sx+1 and y % 4 == 1 then
+
-								term.write(""..((y/4) % 10))
+
-							elseif y == sy + 1 and x % 4 == 1 then
+
-								term.write(""..((x/4) % 10))
+
-							elseif x % 2 == 1 and y % 2 == 1 then
+        Params: none
-								term.write("+")
+        Returns:nil
-							elseif x % 2 == 1 then
+
-								term.write("|")
+
-							elseif y % 2 == 1 then
+        if textEnabled then
-								term.write("-")
+                loadNFT(sPath)
-							else
+                table.insert(ddModes, 2, { "text", "textpaint", name = "text"})
-								term.write(" ")
+        elseif animated then
                 loadNFA(sPath)
-						else
+                table.insert(ddModes, #ddModes, { "record", "play", name = "anim" })
-							term.setBackgroundColour(alphaC)
+                table.insert(ddModes, #ddModes, { "go to", "remove", name = "frames"})
-							term.write(" ")
+                table.insert(ddModes[2], #ddModes[2], "blueprint on")
-						end
+                table.insert(ddModes[2], #ddModes[2], "layers on")
-					end
+        else
                 loadNFP(sPath)
                 table.insert(ddModes[2], #ddModes[2], "blueprint on")
         end
 
         for i=0,15 do
-	--Then the printer, if he's on
+                table.insert(column, math.pow(2,i))
-	if state == "active print" then
+        end
-		local bgColour = alphaC
+
-		if layering == "up" then
+
-			term.setCursorPos(px-sx,pz-sy)
+
-			if frames[sFrame] and frames[sFrame][pz-sy] and frames[sFrame][pz-sy][px-sx] then
+                        Section: Drawing
-				bgColour = frames[sFrame][pz-sy][px-sx]
+
-			elseif blueprint then bgColour = colours.blue end
+
 
-			term.setCursorPos(px-sx,py-sy)
+
-			if frames[sFrame] and frames[sFrame][py-sy] and frames[sFrame][py-sy][px-sx] then
+        actual program.
-				bgColour = frames[sFrame][py-sy][px-sx]
+        Params: none
-			elseif blueprint then bgColour = colours.blue end
+        Returns:bool= true if the file select ran successfully; false otherwise.
 ]]--
 local function drawLogo()
-		term.setBackgroundColour(bgColour)
+        term.setBackgroundColour(colours.white)
-		if bgColour == colours.black then term.setTextColour(colours.white)
+        term.clear()
-		else term.setTextColour(colours.black) end
+		if h >= 12 and w >= 24 then
 			drawPictureTable(logo, w/2 - #logo[1]/2, h/2 - #logo/2, colours.white)
-		term.write(turtlechar)
+			term.setBackgroundColour(colours.white)
 			term.setTextColour(colours.black)
 			local msg = "NPaintPro"
-	--Then the buffer
+			term.setCursorPos(w/2 - #msg/2, h/2 + #logo/2 + 1)
-	if selectrect then
+			term.write(msg)
-		if buffer and rectblink == 1 then
+			msg = "By NitrogenFingers"
-		for y=selectrect.y1, math.min(selectrect.y2, selectrect.y1 + buffer.height-1) do
+			term.setCursorPos(w/2 - #msg/2, h/2 + #logo/2 + 2)
-			for x=selectrect.x1, math.min(selectrect.x2, selectrect.x1 + buffer.width-1) do
+			term.write(msg)
-				if buffer.contents[y-selectrect.y1+1][x-selectrect.x1+1] then
+        elseif w >= 15 then
-					term.setCursorPos(x+sx,y+sy)
+			local msg = "NPaintPro"
-					term.setBackgroundColour(buffer.contents[y-selectrect.y1+1][x-selectrect.x1+1])
+			term.setCursorPos(math.ceil(w/2 - #msg/2), h/2)
-					term.write(" ")
+			term.setTextColour(colours.cyan)
 			term.write(msg)
 			msg = "NitrogenFingers"
 			term.setCursorPos(math.ceil(w/2 - #msg/2), h/2 + 1)
 			term.setTextColour(colours.black)
 			term.write(msg)
-		--This draws the "selection" box
+
-		local add = nil
+			local msg = "NPP"
-		if buffer then
+			term.setCursorPos(math.ceil(w/2 - #msg/2), math.floor(h/2))
 			term.setTextColour(colours.cyan)
-		else
+			term.write(msg)
 			msg = "By NF"
 			term.setCursorPos(math.ceil(w/2 - #msg/2), math.ceil(h/2))
-		for i=selectrect.x1, selectrect.x2 do
+
-			add = (i + selectrect.y1 + rectblink) % 2 == 0
+			term.write(msg)
-			term.setCursorPos(i-sx,selectrect.y1-sy)
+
-			if add then term.write(" ") end
+        os.pullEvent()
-			add = (i + selectrect.y2 + rectblink) % 2 == 0
+
-			term.setCursorPos(i-sx,selectrect.y2-sy)
+
-			if add then term.write(" ") end
+
         rectanlge if any of these things are present.
-		for i=selectrect.y1 + 1, selectrect.y2 - 1 do
+        Params: none
-			add = (i + selectrect.x1 + rectblink) % 2 == 0
+        Returns:nil
-			term.setCursorPos(selectrect.x1-sx,i-sy)
+
-			if add then term.write(" ") end
+
-			add = (i + selectrect.x2 + rectblink) % 2 == 0
+        --We have to readjust the position of the canvas if we're printing
-			term.setCursorPos(selectrect.x2-sx,i-sy)
+        turtlechar = "@"
-			if add then term.write(" ") end
+        if state == "active print" then
                 if layering == "up" then
                         if py >= 1 and py <= #frames then
                                 sFrame = py
                         end
---[[Draws the colour picker on the right side of the screen, the colour pallette and the footer with any
+                        if pz < sy then sy = pz
-	messages currently being displayed
+                        elseif pz > sy + h - 1 then sy = pz + h - 1 end
                         if px < sx then sx = px
                         elseif px > sx + w - 2 then sx = px + w - 2 end
                 else
                         if pz >= 1 and pz <= #frames then
-	--Picker
+                                sFrame = pz
-	for i=1,#column do
+                        end
-		term.setCursorPos(w-1, i)
+
-		term.setBackgroundColour(column[i])
+                        if py < sy then sy = py
-		if state == "print" then
+                        elseif py > sy + h - 1 then sy = py + h - 1 end
-			if i == 16 then
+                        if px < sx then sx = px
-				term.setTextColour(colours.white)
+                        elseif px > sx + w - 2 then sx = px + w - 2 end
                 end
-				term.setTextColour(colours.black)
+
                 if pfx == 1 then turtlechar = ">"
-			if requirementsDisplayed then
+                elseif pfx == -1 then turtlechar = "<"
-				if requiredMaterials[i] < 10 then term.write(" ") end
+                elseif pfz == 1 then turtlechar = "V"
-				term.setCursorPos(w-#tostring(requiredMaterials[i])+1, i)
+                elseif pfz == -1 then turtlechar = "^"
-				term.write(requiredMaterials[i])
+                end
         end
-				if i < 10 then term.write(" ") end
+
-				term.write(i)
+        --Picture next
         local topLayer, botLayer
         if layerDisplay then
-			term.write("  ")
+                topLayer = sFrame
                 botLayer = 1
         else
-	term.setCursorPos(w-1,#column+1)
+                topLayer,botLayer = sFrame,sFrame
-	term.setBackgroundColour(colours.black)
+        end
-	term.setTextColour(colours.red)
+
-	term.write("XX")
+	    --How far the canvas draws. If the interface is visible, it stops short of that.
-	--Pallette
+	    local wlim,hlim = 0,0
-	term.setCursorPos(w-1,h-1)
+		if not interfaceHidden then
-	if not lSel then
+			wlim = 2
-		term.setBackgroundColour(colours.black)
+			hlim = 1
-		term.setTextColour(colours.red)
+
-		term.write("X")
+
         for currframe = botLayer,topLayer,1 do
-		term.setBackgroundColour(lSel)
+                for y=sy+1,sy+h-hlim do
-		term.setTextColour(lSel)
+                        if frames[currframe][y] then
-		term.write(" ")
+                                for x=sx+1,sx+w-wlim do
                                         term.setCursorPos(x-sx,y-sy)
-	if not rSel then
+                                        if frames[currframe][y][x] then
-		term.setBackgroundColour(colours.black)
+                                                term.setBackgroundColour(frames[currframe][y][x])
-		term.setTextColour(colours.red)
+                                                if textEnabled and frames[currframe].textcol[y][x] and frames[currframe].text[y][x] then
-		term.write("X")
+                                                        term.setTextColour(frames[currframe].textcol[y][x])
                                                         term.write(frames[currframe].text[y][x])
-		term.setBackgroundColour(rSel)
+                                                else
-		term.setTextColour(rSel)
+                                                        term.write(" ")
-		term.write(" ")
+                                                end
                                         else
-	--Footer
+                                                tileExists = false
-	if inMenu then return end
+                                                for i=currframe-1,botLayer,-1 do
                                                         if frames[i][y][x] then
-	term.setCursorPos(1, h)
+                                                                tileExists = true
                                                                 break
                                                         end
                                                 end
-	if inDropDown then
+
-		term.write(string.rep(" ", 6))
+                                                if not tileExists then
                                                         if blueprint then
-		term.setBackgroundColour(colours.grey)
+                                                                term.setBackgroundColour(colours.blue)
-		term.setTextColour(colours.lightGrey)
+                                                                term.setTextColour(colours.white)
-		term.write("menu  ")
+                                                                if x == sx+1 and y % 4 == 1 then
                                                                         term.write(""..((y/4) % 10))
                                                                 elseif y == sy + 1 and x % 4 == 1 then
                                                                         term.write(""..((x/4) % 10))
-	term.write(getStateMessage())
+                                                                elseif x % 2 == 1 and y % 2 == 1 then
                                                                         term.write("+")
-	local coords="X:"..sx.." Y:"..sy
+                                                                elseif x % 2 == 1 then
-	if animated then coords = coords.." Frame:"..sFrame.."/"..framecount.."   " end
+                                                                        term.write("|")
-	term.setCursorPos(w-#coords+1,h)
+                                                                elseif y % 2 == 1 then
-	if state == "play" then term.setBackgroundColour(colours.lime)
+                                                                        term.write("-")
-	elseif record then term.setBackgroundColour(colours.red) end
+                                                                else
-	term.write(coords)
+                                                                        term.write(" ")
                                                                 end
-	if animated then
+                                                        else
-		term.setCursorPos(w-1,h)
+                                                                term.setBackgroundColour(alphaC)
-		term.setBackgroundColour(colours.grey)
+                                                                if textEnabled and frames[currframe].textcol[y][x] and frames[currframe].text[y][x] then
-		term.setTextColour(colours.lightGrey)
+                                                                        term.setTextColour(frames[currframe].textcol[y][x])
-		term.write("<>")
+                                                                        term.write(frames[currframe].text[y][x])
                                                                 else
                                                                         term.write(" ")
                                                                 end
                                                         end
                                                 end
                                         end
                                 end
                         else
-	local selectedHelp = nil
+                                for x=sx+1,sx+w-wlim do
                                         term.setCursorPos(x-sx,y-sy)
 
-		term.clear()
+                                        tileExists = false
-		if not selectedHelp then
+                                        for i=currframe-1,botLayer,-1 do
-			term.setCursorPos(4, 1)
+                                                if frames[i][y] and frames[i][y][x] then
-			term.setTextColour(colours.brown)
+                                                        tileExists = true
-			term.write("Available modes (click for info):")
+                                                        break
-			for i=1,#helpTopics do
+                                                end
-				term.setCursorPos(2, 2 + i)
+                                        end
-				term.setTextColour(colours.black)
+
-				term.write(helpTopics[i].name)
+                                        if not tileExists then
-				if helpTopics[i].key then
+                                                if blueprint then
-					term.setTextColour(colours.red)
+                                                        term.setBackgroundColour(colours.blue)
-					term.write(" ("..helpTopics[i].key..")")
+                                                        term.setTextColour(colours.white)
                                                         if x == sx+1 and y % 4 == 1 then
                                                                 term.write(""..((y/4) % 10))
-			term.setCursorPos(4,h)
+                                                        elseif y == sy + 1 and x % 4 == 1 then
                                                                 term.write(""..((x/4) % 10))
-			term.write("Press any key to exit")
+                                                        elseif x % 2 == 1 and y % 2 == 1 then
                                                                 term.write("+")
-			term.setCursorPos(4,1)
+                                                        elseif x % 2 == 1 then
-			term.setTextColour(colours.brown)
+                                                                term.write("|")
-			term.write(helpTopics[selectedHelp].name)
+                                                        elseif y % 2 == 1 then
-			if helpTopics[selectedHelp].key then
+                                                                term.write("-")
                                                         else
-				term.write(" ("..helpTopics[selectedHelp].key..")")
+                                                                term.write(" ")
                                                         end
-			term.setCursorPos(1,3)
+                                                else
                                                         term.setBackgroundColour(alphaC)
-			print(helpTopics[selectedHelp].message.."\n")
+                                                        term.write(" ")
-			for i=1,#helpTopics[selectedHelp].controls do
+                                                end
-				term.setTextColour(colours.brown)
+                                        end
-				term.write(helpTopics[selectedHelp].controls[i][1].." ")
+                                end
-				term.setTextColour(colours.black)
+                        end
-				print(helpTopics[selectedHelp].controls[i][2])
+                end
         end
 
         --Then the printer, if he's on
         if state == "active print" then
                 local bgColour = alphaC
-		if id == "timer" then updateTimer(p1)
+                if layering == "up" then
-		elseif id == "key" then
+                        term.setCursorPos(px-sx,pz-sy)
-			if selectedHelp then selectedHelp = nil
+                        if frames[sFrame] and frames[sFrame][pz-sy] and frames[sFrame][pz-sy][px-sx] then
-			else break end
+                                bgColour = frames[sFrame][pz-sy][px-sx]
                         elseif blueprint then bgColour = colours.blue end
-			if not selectedHelp then
+                else
-				if p3 >=3 and p3 <= 2+#helpTopics then
+                        term.setCursorPos(px-sx,py-sy)
-					selectedHelp = p3-2
+                        if frames[sFrame] and frames[sFrame][py-sy] and frames[sFrame][py-sy][px-sx] then
-				else break end
+                                bgColour = frames[sFrame][py-sy][px-sx]
                         elseif blueprint then bgColour = colours.blue end
-				selectedHelp = nil
+                end
 
                 term.setBackgroundColour(bgColour)
                 if bgColour == colours.black then term.setTextColour(colours.white)
                 else term.setTextColour(colours.black) end
 
                 term.write(turtlechar)
-	inMenu paramter is set to true while this is being done (remember to set it back when done!)
+        end
-	Params: message:string = The message to be drawn
+
         --Then the buffer
         if selectrect then
                 if buffer and rectblink == 1 then
                 for y=selectrect.y1, math.min(selectrect.y2, selectrect.y1 + buffer.height-1) do
                         for x=selectrect.x1, math.min(selectrect.x2, selectrect.x1 + buffer.width-1) do
                                 if buffer.contents[y-selectrect.y1+1][x-selectrect.x1+1] then
                                         term.setCursorPos(x+sx,y+sy)
-	term.write(message)
+                                        term.setBackgroundColour(buffer.contents[y-selectrect.y1+1][x-selectrect.x1+1])
                                         term.write(" ")
                                 end
                         end
-			Section: Generic Interfaces
+                end
                 end
 
                 --This draws the "selection" box
                 local add = nil
-	No colour materials included.
+                if buffer then
-	Params: msg:string = The message to print off-center
+                        term.setBackgroundColour(colours.lightGrey)
-			height:number = The starting height of the message
+                else
-			width:number = The limit as to how many characters long each line may be
+                        term.setBackgroundColour(colours.grey)
-			offset:number = The starting width offset of the message
+                end
-	Returns:number the number of lines used in printing the message
+                for i=selectrect.x1, selectrect.x2 do
                         add = (i + selectrect.y1 + rectblink) % 2 == 0
                         term.setCursorPos(i-sx,selectrect.y1-sy)
-	local inc = 0
+                        if add then term.write(" ") end
-	local ops = 1
+                        add = (i + selectrect.y2 + rectblink) % 2 == 0
-	while #msg - ops > width do
+                        term.setCursorPos(i-sx,selectrect.y2-sy)
-		local nextspace = 0
+                        if add then term.write(" ") end
-		while string.find(msg, " ", ops + nextspace) and
+                end
-				string.find(msg, " ", ops + nextspace) - ops < width do
+                for i=selectrect.y1 + 1, selectrect.y2 - 1 do
-			nextspace = string.find(msg, " ", nextspace + ops) + 1 - ops
+                        add = (i + selectrect.x1 + rectblink) % 2 == 0
                         term.setCursorPos(selectrect.x1-sx,i-sy)
-		local ox,oy = term.getCursorPos()
+                        if add then term.write(" ") end
-		term.setCursorPos(width/2 - (nextspace)/2 + offset, height + inc)
+                        add = (i + selectrect.x2 + rectblink) % 2 == 0
-		inc = inc + 1
+                        term.setCursorPos(selectrect.x2-sx,i-sy)
-		term.write(string.sub(msg, ops, nextspace + ops - 1))
+                        if add then term.write(" ") end
-		ops = ops + nextspace
+                end
         end
-	term.setCursorPos(width/2 - #string.sub(msg, ops)/2 + offset, height + inc)
+
-	term.write(string.sub(msg, ops))
+
 --[[Draws the colour picker on the right side of the screen, the colour pallette and the footer with any
-	return inc + 1
+        messages currently being displayed
         Params: none
         Returns:nil
 ]]--
-	generic information.
+
-	Params: ctitle:string = The title of the confirm dialogue
+        --Picker
-			msg:string = The message displayed in the dialogue
+		local coffset,ioffset = 0,0
 		local maxcsize = h-2
 		if h < #column + 2 then
 			maxcsize = h-4
-	local dialogoffset = 8
+			coffset = columnoffset
-	--We actually print twice- once to get the lines, second time to print proper. Easier this way.
+			ioffset = 1
-	local lines = wprintOffCenter(msg, 5, w - (dialogoffset+2) * 2, dialogoffset + 2)
+
 			term.setTextColour(colours.grey)
-	term.setCursorPos(dialogoffset, 3)
+			term.setCursorPos(w-1,1)
-	term.setBackgroundColour(colours.grey)
+			term.write("^^")
-	term.setTextColour(colours.lightGrey)
+			term.setCursorPos(w-1,h-2)
-	term.write(string.rep(" ", w - dialogoffset * 2))
+			term.write("VV")
-	term.setCursorPos(dialogoffset + (w - dialogoffset * 2)/2 - #ctitle/2, 3)
+
-	term.write(ctitle)
+        for i=1,math.min(#column+1,maxcsize) do
 			term.setCursorPos(w-1, i + ioffset)
 			local ci = i+coffset
-	term.setCursorPos(dialogoffset, 4)
+			if ci == #column+1 then
-	term.write(string.rep(" ", w - dialogoffset * 2))
+				term.setBackgroundColour(colours.black)
-	for i=5,5+lines do
+
-		term.setCursorPos(dialogoffset, i)
+				term.write("XX")
-		term.write(" "..string.rep(" ", w - (dialogoffset) * 2 - 2).." ")
+			elseif state == "print" then
 				term.setBackgroundColour(column[ci])
-	wprintOffCenter(msg, 5, w - (dialogoffset+2) * 2, dialogoffset + 2)
+				if column[ci] == colours.black then
 					term.setTextColour(colours.white)
-	--In the event of a message, the player hits anything to continue
+				else term.setTextColour(colours.black) end
 
-		local id,key = os.pullEvent()
+				if requirementsDisplayed then
-		if id == "timer" then updateTimer(key);
+						if requiredMaterials[i] < 10 then term.write(" ") end
-		elseif id == "key" or id == "mouse_click" or id == "mouse_drag" then break end
+						term.setCursorPos(w-#tostring(requiredMaterials[i])+1, i)
 						term.write(requiredMaterials[i])
 				else
 						if i+coffset < 10 then term.write(" ") end
 						term.write(i+coffset)
-	of the menu drawn, and allows nesting of menus and sub menus. Clicking anywhere outside the menu will cancel and return nothing
+
-	Params: x:int = the x position the menu should be displayed at
+
-			y:int = the y position the menu should be displayed at
+				term.setBackgroundColour(column[ci])
-			options:table = the list of options available to the user, as strings or submenus (tables of strings, with a name parameter)
+				term.write("  ")
-	Returns:string the selected menu option.
+
         end
 		--Filling the whitespace with... 'greyspace' *shudder*
-	inDropDown = true
+		if h > #column+3 then
-	--Figures out the dimensions of our thing
+			term.setTextColour(colours.grey)
-	local longestX = #options.name
+
-	for i=1,#options do
+			for y=#column+2,h-2 do
-		local currVal = options[i]
+				term.setCursorPos(w-1,y)
-		if type(currVal) == "table" then currVal = currVal.name end
+				term.write("| ")
 			end
-		longestX = math.max(longestX, #currVal)
+
         --Pallette
-	local xOffset = math.max(0, longestX - ((w-2) - x) + 1)
+        term.setCursorPos(w-1,h-1)
-	local yOffset = math.max(0, #options - ((h-1) - y))
+        if not lSel then
                 term.setBackgroundColour(colours.black)
-	local clickTimes = 0
+                term.setTextColour(colours.red)
-	local tid = nil
+                term.write("X")
-	local selection = nil
+        else
-	while clickTimes < 2 do
+                term.setBackgroundColour(lSel)
-		drawCanvas()
+                term.setTextColour(lSel)
-		drawInterface()
+                term.write(" ")
         end
-		term.setCursorPos(x-xOffset,y-yOffset)
+        if not rSel then
-		term.setBackgroundColour(colours.grey)
+                term.setBackgroundColour(colours.black)
-		term.setTextColour(colours.lightGrey)
+                term.setTextColour(colours.red)
-		term.write(options.name..string.rep(" ", longestX-#options.name + 2))
+                term.write("X")
         else
-		for i=1,#options do
+                term.setBackgroundColour(rSel)
-			term.setCursorPos(x-xOffset, y-yOffset+i)
+                term.setTextColour(rSel)
-			if i==selection and clickTimes % 2 == 0 then
+                term.write(" ")
-				term.setBackgroundColour(colours.grey)
+        end
-				term.setTextColour(colours.lightGrey)
+        --Footer
         if inMenu then return end
-				term.setBackgroundColour(colours.lightGrey)
+
-				term.setTextColour(colours.grey)
+        term.setCursorPos(1, h)
         term.setBackgroundColour(colours.lightGrey)
-			local currVal = options[i]
+        term.setTextColour(colours.grey)
-			if type(currVal) == "table" then
+        term.clearLine()
-				term.write(currVal.name..string.rep(" ", longestX-#currVal.name + 1))
+		if mainAvailable then
-				term.setBackgroundColour(colours.grey)
+			if inDropDown then
-				term.setTextColour(colours.lightGrey)
+					term.write(string.rep(" ", #ddModes.name + 2))
-				term.write(">")
+
 					term.setBackgroundColour(colours.grey)
-				term.write(currVal..string.rep(" ", longestX-#currVal + 2))
+					term.setTextColour(colours.lightGrey)
 					term.write(ddModes.name.."  ")
 			end
 		end
-		local id, p1, p2, p3 = os.pullEvent()
+        term.setBackgroundColour(colours.lightGrey)
-		if id == "timer" then
+        term.setTextColour(colours.grey)
-			if p1 == tid then
+        term.write(getStateMessage())
-				clickTimes = clickTimes + 1
+
-				if clickTimes > 2 then
+        local coords="X:"..sx.." Y:"..sy
-					break
+        if animated then coords = coords.." Frame:"..sFrame.."/"..framecount.."   " end
-				else
+        term.setCursorPos(w-#coords+1,h)
-					tid = os.startTimer(0.1)
+        if state == "play" then term.setBackgroundColour(colours.lime)
         elseif record then term.setBackgroundColour(colours.red) end
-			else
+        term.write(coords)
-				updateTimer(p1)
+
-				drawCanvas()
+        if animated then
-				drawInterface()
+                term.setCursorPos(w-1,h)
                 term.setBackgroundColour(colours.grey)
                 term.setTextColour(colours.lightGrey)
-			if p2 >=x-xOffset and p2 <= x-xOffset + longestX + 1 and p3 >= y-yOffset+1 and p3 <= y-yOffset+#options then
+                term.write("<>")
-				selection = p3-(y-yOffset)
+        end
-				tid = os.startTimer(0.1)
+
 
-				selection = ""
+
-				break
+        Params: none
         Returns:nil
 ]]--
 local function drawHelpScreen()
         local selectedHelp = nil
-	if type(selection) == "number" then
+        while true do
-		selection = options[selection]
+                term.setBackgroundColour(colours.lightGrey)
                 term.clear()
                 if not selectedHelp then
-	if type(selection) == "string" then
+                        term.setCursorPos(4, 1)
-		inDropDown = false
+                        term.setTextColour(colours.brown)
-		return selection
+                        term.write("Available modes (click for info):")
-	elseif type(selection) == "table" then
+                        for i=1,#helpTopics do
-		return displayDropDown(x, y, selection)
+                                term.setCursorPos(2, 2 + i)
                                 term.setTextColour(colours.black)
                                 term.write(helpTopics[i].name)
                                 if helpTopics[i].key then
                                         term.setTextColour(colours.red)
-	waits a 1/100th of a second so any keys still in the event library are removed before input is read and
+                                        term.write(" ("..helpTopics[i].key..")")
-	the timer for the selectionrectangle is continuously updated during the process.
+                                end
-	Params: lim:int = the number of characters input is allowed
+                        end
-	Returns:string the inputted string, trimmed of leading and tailing whitespace
+                        term.setCursorPos(4,h)
                         term.setTextColour(colours.black)
                         term.write("Press any key to exit")
-	term.setCursorBlink(true)
+                else
                         term.setCursorPos(4,1)
-	local inputString = ""
+                        term.setTextColour(colours.brown)
-	if not lim or type(lim) ~= "number" or lim < 1 then lim = w - ox end
+                        term.write(helpTopics[selectedHelp].name)
-	local ox,oy = term.getCursorPos()
+                        if helpTopics[selectedHelp].key then
-	--We only get input from the footer, so this is safe. Change if recycling
+                                term.setTextColour(colours.red)
                                 term.write(" ("..helpTopics[selectedHelp].key..")")
                         end
-	term.write(string.rep(" ", lim))
+                        term.setCursorPos(1,3)
-	term.setCursorPos(ox, oy)
+                        term.setTextColour(colours.black)
-	--As events queue immediately, we may get an unwanted key... this will solve that problem
+                        print(helpTopics[selectedHelp].message.."\n")
-	local inputTimer = os.startTimer(0.01)
+                        for i=1,#helpTopics[selectedHelp].controls do
-	local keysAllowed = false
+                                term.setTextColour(colours.brown)
                                 term.write(helpTopics[selectedHelp].controls[i][1].." ")
                                 term.setTextColour(colours.black)
-		local id,key = os.pullEvent()
+                                print(helpTopics[selectedHelp].controls[i][2])
                         end
-		if keysAllowed then
+                end
-			if id == "key" and key == 14 and #inputString > 0 then
+
-				inputString = string.sub(inputString, 1, #inputString-1)
+                local id,p1,p2,p3 = os.pullEvent()
-				term.setCursorPos(ox + #inputString,oy)
+
-				term.write(" ")
+                if id == "timer" then updateTimer(p1)
-			elseif id == "key" and key == 28 and inputString ~= string.rep(" ", #inputString) then
+                elseif id == "key" then
-				break
+                        if selectedHelp then selectedHelp = nil
-			elseif id == "key" and key == keys.leftCtrl then
+                        else break end
-				return ""
+                elseif id == "mouse_click" then
-			elseif id == "char" and #inputString < lim then
+                        if not selectedHelp then
-				inputString = inputString..key
+                                if p3 >=3 and p3 <= 2+#helpTopics then
                                         selectedHelp = p3-2
                                 else break end
                         else
-		if id == "timer" then
+                                selectedHelp = nil
-			if key == inputTimer then
+                        end
-				keysAllowed = true
+                end
         end
-				updateTimer(key)
+
-				drawCanvas()
+
-				drawInterface()
+
-				term.setBackgroundColour(colours.lightGrey)
+        inMenu paramter is set to true while this is being done (remember to set it back when done!)
-				term.setTextColour(colours.grey)
+        Params: message:string = The message to be drawn
         Returns:nil
 ]]--
-		term.setCursorPos(ox,oy)
+
-		term.write(inputString)
+        term.setCursorPos(1,h)
-		term.setCursorPos(ox + #inputString, oy)
+        term.setBackgroundColour(colours.lightGrey)
         term.setTextColour(colours.grey)
         term.clearLine()
-	while string.sub(inputString, 1, 1) == " " do
+        term.write(message)
-		inputString = string.sub(inputString, 2, #inputString)
+
 
-	while string.sub(inputString, #inputString, #inputString) == " " do
+
-		inputString = string.sub(inputString, 1, #inputString-1)
+                        Section: Generic Interfaces
 ]]--
-	term.setCursorBlink(false)
+
 
-	return inputString
+
         No colour materials included.
         Params: msg:string = The message to print off-center
                         height:number = The starting height of the message
-			Section: Image tools
+                        width:number = The limit as to how many characters long each line may be
                         offset:number = The starting width offset of the message
         Returns:number the number of lines used in printing the message
 ]]--
 local function wprintOffCenter(msg, height, width, offset)
-	Params: removeImage:bool = true if the image is to be erased after copying, false otherwise
+        local inc = 0
         local ops = 1
         while #msg - ops > width do
                 local nextspace = 0
-	buffer = { width = selectrect.x2 - selectrect.x1 + 1, height = selectrect.y2 - selectrect.y1 + 1, contents = { } }
+                while string.find(msg, " ", ops + nextspace) and
                                 string.find(msg, " ", ops + nextspace) - ops < width do
-	local containsSomething = false
+                        nextspace = string.find(msg, " ", nextspace + ops) + 1 - ops
-	for y=1,buffer.height do
+                end
-		buffer.contents[y] = { }
+                local ox,oy = term.getCursorPos()
-		local f,l = sFrame,sFrame
+                term.setCursorPos(width/2 - (nextspace)/2 + offset, height + inc)
-		if record then f,l = 1, framecount end
+                inc = inc + 1
                 term.write(string.sub(msg, ops, nextspace + ops - 1))
-		for fra = f,l do
+                ops = ops + nextspace
-			if frames[fra][selectrect.y1 + y - 1] then
+        end
-				for x=1,buffer.width do
+        term.setCursorPos(width/2 - #string.sub(msg, ops)/2 + offset, height + inc)
-					buffer.contents[y][x] = frames[sFrame][selectrect.y1 + y - 1][selectrect.x1 + x - 1]
+        term.write(string.sub(msg, ops))
-					if removeImage then frames[fra][selectrect.y1 + y - 1][selectrect.x1 + x - 1] = nil end
+
-					if buffer.contents[y][x] then containsSomething = true end
+        return inc + 1
 end
 
 --[[Draws a message that must be clicked on or a key struck to be cleared. No options, so used for displaying
         generic information.
-	--I don't classify an empty buffer as a real buffer- confusing to the user.
+        Params: ctitle:string = The title of the confirm dialogue
-	if not containsSomething then buffer = nil end
+                        msg:string = The message displayed in the dialogue
         Returns:nil
 ]]--
 local function displayConfirmDialogue(ctitle, msg)
-	Params: removeBuffer:bool = true if the buffer is to be emptied after copying, false otherwise
+        local dialogoffset = 8
         --We actually print twice- once to get the lines, second time to print proper. Easier this way.
         local lines = wprintOffCenter(msg, 5, w - (dialogoffset+2) * 2, dialogoffset + 2)
 
-	if not buffer then return end
+        term.setCursorPos(dialogoffset, 3)
         term.setBackgroundColour(colours.grey)
-	for y = 1, math.min(buffer.height,selectrect.y2-selectrect.y1+1) do
+        term.setTextColour(colours.lightGrey)
-		local f,l = sFrame, sFrame
+        term.write(string.rep(" ", w - dialogoffset * 2))
-		if record then f,l = 1, framecount end
+        term.setCursorPos(dialogoffset + (w - dialogoffset * 2)/2 - #ctitle/2, 3)
         term.write(ctitle)
-		for fra = f,l do
+        term.setTextColour(colours.grey)
-			if not frames[fra][selectrect.y1+y-1] then frames[fra][selectrect.y1+y-1] = { } end
+        term.setBackgroundColour(colours.lightGrey)
-			for x = 1, math.min(buffer.width,selectrect.x2-selectrect.x1+1) do
+        term.setCursorPos(dialogoffset, 4)
-				frames[fra][selectrect.y1+y-1][selectrect.x1+x-1] = buffer.contents[y][x]
+        term.write(string.rep(" ", w - dialogoffset * 2))
         for i=5,5+lines do
                 term.setCursorPos(dialogoffset, i)
                 term.write(" "..string.rep(" ", w - (dialogoffset) * 2 - 2).." ")
         end
-	if removeBuffer then buffer = nil end
+        wprintOffCenter(msg, 5, w - (dialogoffset+2) * 2, dialogoffset + 2)
 
         --In the event of a message, the player hits anything to continue
         while true do
-	Params: newx:int = the X coordinate to move the image to
+                local id,key = os.pullEvent()
-			newy:int = the Y coordinate to move the image to
+                if id == "timer" then updateTimer(key);
                 elseif id == "key" or id == "mouse_click" or id == "mouse_drag" then break end
         end
 end
-	if not leflim or not toplim then return end
+
-	if newx <=0 or newy <=0 then return end
+
-	local f,l = sFrame,sFrame
+        of the menu drawn, and allows nesting of menus and sub menus. Clicking anywhere outside the menu will cancel and return nothing
-	if record then f,l = 1,framecount end
+        Params: x:int = the x position the menu should be displayed at
                         y:int = the y position the menu should be displayed at
-	for i=f,l do
+                        options:table = the list of options available to the user, as strings or submenus (tables of strings, with a name parameter)
-		local newlines = { }
+        Returns:string the selected menu option.
-		for y=toplim,botlim do
+
-			local line = frames[i][y]
+
-			if line then
+        inDropDown = true
-				newlines[y-toplim+newy] = { }
+        --Figures out the dimensions of our thing
-				for x,char in pairs(line) do
+        local longestX = #options.name
-					newlines[y-toplim+newy][x-leflim+newx] = char
+        for i=1,#options do
                 local currVal = options[i]
                 if type(currVal) == "table" then currVal = currVal.name end
 
-		--Exceptions that allow us to move the text as well
+                longestX = math.max(longestX, #currVal)
-		if textEnabled then
+        end
-			newlines.text = { }
+        local xOffset = math.max(0, longestX - ((w-2) - x) + 1)
-			for y=toplim,botlim do
+        local yOffset = math.max(0, #options - ((h-1) - y))
-				local line = frames[i].text[y]
+
-				if line then
+        local clickTimes = 0
-					newlines.text[y-toplim+newy] = { }
+        local tid = nil
-					for x,char in pairs(line) do
+        local selection = nil
-						newlines.text[y-toplim+newy][x-leflim+newx] = char
+        while clickTimes < 2 do
-					end
+                drawCanvas()
                 drawInterface()
 
                 term.setCursorPos(x-xOffset,y-yOffset)
-			newlines.textcol = { }
+                term.setBackgroundColour(colours.grey)
-			for y=toplim,botlim do
+                term.setTextColour(colours.lightGrey)
-				local line = frames[i].textcol[y]
+                term.write(options.name..string.rep(" ", longestX-#options.name + 2))
-				if line then
+
-					newlines.textcol[y-toplim+newy] = { }
+                for i=1,#options do
-					for x,char in pairs(line) do
+                        term.setCursorPos(x-xOffset, y-yOffset+i)
-						newlines.textcol[y-toplim+newy][x-leflim+newx] = char
+                        if i==selection and clickTimes % 2 == 0 then
-					end
+                                term.setBackgroundColour(colours.grey)
                                 term.setTextColour(colours.lightGrey)
                         else
                                 term.setBackgroundColour(colours.lightGrey)
                                 term.setTextColour(colours.grey)
-		frames[i] = newlines
+                        end
                         local currVal = options[i]
                         if type(currVal) == "table" then
                                 term.write(currVal.name..string.rep(" ", longestX-#currVal.name + 1))
                                 term.setBackgroundColour(colours.grey)
                                 term.setTextColour(colours.lightGrey)
                                 term.write(">")
                         else
                                 term.write(currVal..string.rep(" ", longestX-#currVal + 2))
-	inMenu = true
+                        end
-	if not animated then
+                end
-		drawMessage("Clear image? Y/N: ")
+
-	elseif record then
+                local id, p1, p2, p3 = os.pullEvent()
-		drawMessage("Clear ALL frames? Y/N: ")
+                if id == "timer" then
                         if p1 == tid then
-		drawMessage("Clear current frame? Y/N :")
+                                clickTimes = clickTimes + 1
                                 if clickTimes > 2 then
-	if string.find(string.upper(readInput(1)), "Y") then
+                                        break
-		local f,l = sFrame,sFrame
+                                else
-		if record then f,l = 1,framecount end
+                                        tid = os.startTimer(0.1)
                                 end
-		for i=f,l do
+                        else
-			frames[i] = { }
+                                updateTimer(p1)
                                 drawCanvas()
                                 drawInterface()
-	inMenu = false
+                        end
                 elseif id == "mouse_click" then
                         if p2 >=x-xOffset and p2 <= x-xOffset + longestX + 1 and p3 >= y-yOffset+1 and p3 <= y-yOffset+#options then
                                 selection = p3-(y-yOffset)
-	changed to another colour. Does not work on the nil colour, for obvious reasons.
+                                tid = os.startTimer(0.1)
-	Params: x:int = The X coordinate of the colour to flood-fill
+                        else
-			y:int = The Y coordinate of the colour to flood-fill
+                                selection = ""
-			targetColour:colour = the colour that is being flood-filled
+                                break
-			newColour:colour = the colour with which to replace the target colour
+                        end
                 end
         end
 
-	if not newColour or not targetColour then return end
+        if type(selection) == "number" then
-	local nodeList = { }
+                selection = options[selection]
         end
-	table.insert(nodeList, {x = x, y = y})
+
         if type(selection) == "string" then
-	while #nodeList > 0 do
+                inDropDown = false
-		local node = nodeList[1]
+                return selection
-		if frames[sFrame][node.y] and frames[sFrame][node.y][node.x] == targetColour then
+        elseif type(selection) == "table" then
-			frames[sFrame][node.y][node.x] = newColour
+                return displayDropDown(x, y, selection)
-			table.insert(nodeList, { x = node.x + 1, y = node.y})
+        end
-			table.insert(nodeList, { x = node.x, y = node.y + 1})
+
-			if x > 1 then table.insert(nodeList, { x = node.x - 1, y = node.y}) end
+
-			if y > 1 then table.insert(nodeList, { x = node.x, y = node.y - 1}) end
+
         waits a 1/100th of a second so any keys still in the event library are removed before input is read and
-		table.remove(nodeList, 1)
+        the timer for the selectionrectangle is continuously updated during the process.
         Params: lim:int = the number of characters input is allowed
         Returns:string the inputted string, trimmed of leading and tailing whitespace
 ]]--
 local function readInput(lim)
-			Section: Animation Tools
+        term.setCursorBlink(true)
 
         local inputString = ""
         if not lim or type(lim) ~= "number" or lim < 1 then lim = w - ox end
-	and method only leaves once the player leaves play mode.
+        local ox,oy = term.getCursorPos()
         --We only get input from the footer, so this is safe. Change if recycling
         term.setBackgroundColour(colours.lightGrey)
         term.setTextColour(colours.grey)
         term.write(string.rep(" ", lim))
-	state = "play"
+        term.setCursorPos(ox, oy)
-	selectedrect = nil
+        --As events queue immediately, we may get an unwanted key... this will solve that problem
         local inputTimer = os.startTimer(0.01)
-	local animt = os.startTimer(animtime)
+        local keysAllowed = false
-	repeat
+
-		drawCanvas()
+        while true do
-		drawInterface()
+                local id,key = os.pullEvent()
 
-		local id,key,_,y = os.pullEvent()
+                if keysAllowed then
                         if id == "key" and key == 14 and #inputString > 0 then
-		if id=="timer" then
+                                inputString = string.sub(inputString, 1, #inputString-1)
-			if key == animt then
+                                term.setCursorPos(ox + #inputString,oy)
-				animt = os.startTimer(animtime)
+                                term.write(" ")
-				sFrame = (sFrame % framecount) + 1
+                        elseif id == "key" and key == 28 and inputString ~= string.rep(" ", #inputString) then
                                 break
-				updateTimer(key)
+                        elseif id == "key" and key == keys.leftCtrl then
                                 return ""
-		elseif id=="key" then
+                        elseif id == "char" and #inputString < lim then
-			if key == keys.comma and animtime > 0.1 then animtime = animtime - 0.05
+                                inputString = inputString..key
-			elseif key == keys.period and animtime < 0.5 then animtime = animtime + 0.05
+                        end
-			elseif key == keys.space then state = "paint" end
+                end
-		elseif id=="mouse_click" and y == h then
+
-			state = "paint"
+                if id == "timer" then
                         if key == inputTimer then
-	until state ~= "play"
+                                keysAllowed = true
-	os.startTimer(0.5)
+                        else
                                 updateTimer(key)
                                 drawCanvas()
                                 drawInterface()
-	additional frames are created with a copy of the image on the selected frame.
+                                term.setBackgroundColour(colours.lightGrey)
-	Params: newframe:int = the new frame to move to
+                                term.setTextColour(colours.grey)
                         end
                 end
                 term.setCursorPos(ox,oy)
-	inMenu = true
+                term.write(inputString)
-	if not tonumber(newframe) then
+                term.setCursorPos(ox + #inputString, oy)
-		term.setCursorPos(1,h)
+        end
 
         while string.sub(inputString, 1, 1) == " " do
-		term.clearLine()
+                inputString = string.sub(inputString, 2, #inputString)
         end
-		term.write("Go to frame: ")
+        while string.sub(inputString, #inputString, #inputString) == " " do
-		newframe = tonumber(readInput(2))
+                inputString = string.sub(inputString, 1, #inputString-1)
-		if not newframe or newframe <= 0 then
+        end
-			inMenu = false
+        term.setCursorBlink(false)
-			return
+
         return inputString
-	elseif newframe <= 0 then return end
+
 
-	if newframe > framecount then
+
-		for i=framecount+1,newframe do
+                        Section: Image tools
-			frames[i] = {}
+
-			for y,line in pairs(frames[sFrame]) do
+
-				frames[i][y] = { }
+
-				for x,v in pairs(line) do
+
-					frames[i][y][x] = v
+        Params: removeImage:bool = true if the image is to be erased after copying, false otherwise
         Returns:nil
 ]]--
 local function copyToBuffer(removeImage)
-		framecount = newframe
+        buffer = { width = selectrect.x2 - selectrect.x1 + 1, height = selectrect.y2 - selectrect.y1 + 1, contents = { } }
 
-	sFrame = newframe
+        local containsSomething = false
-	inMenu = false
+        for y=1,buffer.height do
                 buffer.contents[y] = { }
                 local f,l = sFrame,sFrame
                 if record then f,l = 1, framecount end
-	Params: frame:int the non-inclusive lower bounds of the delete
+
                 for fra = f,l do
                         if frames[fra][selectrect.y1 + y - 1] then
                                 for x=1,buffer.width do
-	inMenu = true
+                                        buffer.contents[y][x] = frames[sFrame][selectrect.y1 + y - 1][selectrect.x1 + x - 1]
-	if frame==framecount then return end
+                                        if removeImage then frames[fra][selectrect.y1 + y - 1][selectrect.x1 + x - 1] = nil end
-	drawMessage("Remove frames "..(frame+1).."/"..framecount.."? Y/N :")
+                                        if buffer.contents[y][x] then containsSomething = true end
-	local answer = string.upper(readInput(1))
+                                end
                         end
-	if string.find(answer, string.upper("Y")) ~= 1 then
+                end
-		inMenu = false
+        end
-		return
+        --I don't classify an empty buffer as a real buffer- confusing to the user.
         if not containsSomething then buffer = nil end
 end
-	for i=frame+1, framecount do
+
-		frames[i] = nil
+
         Params: removeBuffer:bool = true if the buffer is to be emptied after copying, false otherwise
-	framecount = frame
+        Returns:nil
-	inMenu = false
+
 local function copyFromBuffer(removeBuffer)
         if not buffer then return end
 
-			Section: Printing Tools
+        for y = 1, math.min(buffer.height,selectrect.y2-selectrect.y1+1) do
                 local f,l = sFrame, sFrame
                 if record then f,l = 1, framecount end
 
-	Params: curx:number = The facing on the X axis
+                for fra = f,l do
-			curz:number = The facing on the Z axis
+                        if not frames[fra][selectrect.y1+y-1] then frames[fra][selectrect.y1+y-1] = { } end
-			hand:string = The hand of the axis ("right" or "left")
+                        for x = 1, math.min(buffer.width,selectrect.x2-selectrect.x1+1) do
-	Returns:number,number = the new facing on the X and Z axis after a left turn
+                                frames[fra][selectrect.y1+y-1][selectrect.x1+x-1] = buffer.contents[y][x]
                         end
                 end
-	local hand = "left"
+        end
-	if layering == "up" then hand = "right" end
+
         if removeBuffer then buffer = nil end
-	if hand == "right" then
+
-		if curx == 1 then return 0,-1 end
+
-		if curx == -1 then return 0,1 end
+
-		if curz == 1 then return 1,0 end
+        Params: newx:int = the X coordinate to move the image to
-		if curz == -1 then return -1,0 end
+                        newy:int = the Y coordinate to move the image to
         Returns:nil
-		if curx == 1 then return 0,1 end
+
-		if curx == -1 then return 0,-1 end
+
-		if curz == 1 then return -1,0 end
+        if not leflim or not toplim then return end
-		if curz == -1 then return 1,0 end
+        if newx <=0 or newy <=0 then return end
         local f,l = sFrame,sFrame
         if record then f,l = 1,framecount end
 
         for i=f,l do
-	Params: curx:number = The facing on the X axis
+                local newlines = { }
-			curz:number = The facing on the Z axis
+                for y=toplim,botlim do
-			hand:string = The hand of the axis ("right" or "left")
+                        local line = frames[i][y]
-	Returns:number,number = the new facing on the X and Z axis after a right turn
+                        if line then
                                 newlines[y-toplim+newy] = { }
                                 for x,char in pairs(line) do
-	local hand = "left"
+                                        newlines[y-toplim+newy][x-leflim+newx] = char
-	if layering == "up" then hand = "right" end
+                                end
                         end
-	if hand == "right" then
+                end
-		if curx == 1 then return 0,1 end
+                --Exceptions that allow us to move the text as well
-		if curx == -1 then return 0,-1 end
+                if textEnabled then
-		if curz == 1 then return -1,0 end
+                        newlines.text = { }
-		if curz == -1 then return 1,0 end
+                        for y=toplim,botlim do
                                 local line = frames[i].text[y]
-		if curx == 1 then return 0,-1 end
+                                if line then
-		if curx == -1 then return 0,1 end
+                                        newlines.text[y-toplim+newy] = { }
-		if curz == 1 then return 1,0 end
+                                        for x,char in pairs(line) do
-		if curz == -1 then return -1,0 end
+                                                newlines.text[y-toplim+newy][x-leflim+newx] = char
                                         end
                                 end
                         end
 
                         newlines.textcol = { }
-	printerList (for ID's) and printerNames (for names)
+                        for y=toplim,botlim do
-	Params: nil
+                                local line = frames[i].textcol[y]
                                 if line then
                                         newlines.textcol[y-toplim+newy] = { }
                                         for x,char in pairs(line) do
-	printerList = { }
+                                                newlines.textcol[y-toplim+newy][x-leflim+newx] = char
-	printerNames = { name = "Printers" }
+                                        end
-	local oldState = state
+                                end
-	state = "Locating printers, please wait...   "
+                        end
-	drawCanvas()
+                end
-	drawInterface()
+
-	state = oldState
+                frames[i] = newlines
         end
-	local modemOpened = false
+
-	for k,v in pairs(rs.getSides()) do
+
-		if peripheral.isPresent(v) and peripheral.getType(v) == "modem" then
+
-			rednet.open(v)
+        Params: none
-			modemOpened = true
+        Returns:nil
-			break
+
 local function clearImage()
         inMenu = true
         if not animated then
-	if not modemOpened then
+                drawMessage("Clear image? Y/N: ")
-		displayConfirmDialogue("Modem not found!", "No modem peripheral. Must have network modem to locate printers.")
+        elseif record then
-		return false
+                drawMessage("Clear ALL frames? Y/N: ")
         else
                 drawMessage("Clear current frame? Y/N :")
-	rednet.broadcast("$3DPRINT IDENTIFY")
+        end
         if string.find(string.upper(readInput(1)), "Y") then
                 local f,l = sFrame,sFrame
-		local id, msg = rsTimeReceive(1)
+                if record then f,l = 1,framecount end
 
-		if not id then break end
+                for i=f,l do
-		if string.find(msg, "$3DPRINT IDACK") == 1 then
+                        frames[i] = { }
-			msg = string.gsub(msg, "$3DPRINT IDACK ", "")
+                end
-			table.insert(printerList, id)
+        end
-			table.insert(printerNames, msg)
+        inMenu = false
 end
 
 --[[A recursively called method (watch out for big calls!) in which every pixel of a set colour is
-	if #printerList == 0 then
+        changed to another colour. Does not work on the nil colour, for obvious reasons.
-		displayConfirmDialogue("Printers not found!", "No active printers found in proximity of this computer.")
+        Params: x:int = The X coordinate of the colour to flood-fill
-		return false
+                        y:int = The Y coordinate of the colour to flood-fill
                         targetColour:colour = the colour that is being flood-filled
-		return true
+                        newColour:colour = the colour with which to replace the target colour
         Returns:nil
 ]]--
 local function floodFill(x, y, targetColour, newColour)
         if not newColour or not targetColour then return end
-	Params: command:string the command to send
+        local nodeList = { }
-			param:string a parameter to send, if any
+
         table.insert(nodeList, {x = x, y = y})
 
         while #nodeList > 0 do
-	local msg = "$PC "..command
+                local node = nodeList[1]
-	if param then msg = msg.." "..param end
+                if frames[sFrame][node.y] and frames[sFrame][node.y][node.x] == targetColour then
-	rednet.send(printerList[selectedPrinter], msg)
+                        frames[sFrame][node.y][node.x] = newColour
                         table.insert(nodeList, { x = node.x + 1, y = node.y})
                         table.insert(nodeList, { x = node.x, y = node.y + 1})
-		local id,key = rsTimeReceive()
+                        if x > 1 then table.insert(nodeList, { x = node.x - 1, y = node.y}) end
-		if id == printerList[selectedPrinter] then
+                        if y > 1 then table.insert(nodeList, { x = node.x, y = node.y - 1}) end
-			if key == "$3DPRINT ACK" then
+                end
-				break
+                table.remove(nodeList, 1)
-			elseif key == "$3DPRINT DEP" then
+        end
-				displayConfirmDialogue("Printer Empty", "The printer has exhasted a material. Please refill slot "..param..
+
-					", and click this message when ready to continue.")
+
-				rednet.send(printerList[selectedPrinter], msg)
+
-			elseif key == "$3DPRINT OOF" then
+                        Section: Animation Tools
-				displayConfirmDialogue("Printer Out of Fuel", "The printer has no fuel. Please replace the material "..
+
-					"in slot 1 with a fuel source, then click this message.")
+
-				rednet.send(printerList[selectedPrinter], "$PC SS 1")
+
-				id,key = rsTimeReceive()
+        and method only leaves once the player leaves play mode.
-				rednet.send(printerList[selectedPrinter], "$PC RF")
+        Params: none
-				id,key = rsTimeReceive()
+        Returns:nil
-				rednet.send(printerList[selectedPrinter], msg)
+
 local function playAnimation()
         state = "play"
         selectedrect = nil
 
-	--Changes to position are handled after the event has been successfully completed
+        local animt = os.startTimer(animtime)
-	if command == "FW" then
+        repeat
-		px = px + pfx
+                drawCanvas()
-		pz = pz + pfz
+                drawInterface()
-	elseif command == "BK" then
+
-		px = px - pfx
+                local id,key,_,y = os.pullEvent()
-		pz = pz - pfz
+
-	elseif command == "UP" then
+                if id=="timer" then
-		if layering == "up" then
+                        if key == animt then
-			py = py + 1
+                                animt = os.startTimer(animtime)
-		else
+                                sFrame = (sFrame % framecount) + 1
-			py = py - 1
+                        else
                                 updateTimer(key)
-	elseif command == "DW" then
+                        end
-		if layering == "up" then
+                elseif id=="key" then
-			py = py - 1
+                        if key == keys.comma and animtime > 0.1 then animtime = animtime - 0.05
-		else
+                        elseif key == keys.period and animtime < 0.5 then animtime = animtime + 0.05
-			py = py + 1
+                        elseif key == keys.space then state = "paint" end
                 elseif id=="mouse_click" and y == h then
-	elseif command == "TL" then
+                        state = "paint"
-		pfx,pfz = getLeft(pfx,pfz)
+                end
-	elseif command == "TR" then
+        until state ~= "play"
-		pfx,pfz = getRight(pfx,pfz)
+        os.startTimer(0.5)
-	elseif command == "TU" then
+
-		pfx = -pfx
+
-		pfz = -pfz
+
         additional frames are created with a copy of the image on the selected frame.
         Params: newframe:int = the new frame to move to
-	drawCanvas()
+        Returns:nil
-	drawInterface()
+
 local function changeFrame(newframe)
         inMenu = true
         if not tonumber(newframe) then
-	Params: desx:number = the normalized x direction to face
+                term.setCursorPos(1,h)
-			desz:number = the normalized z direction to face
+                term.setBackgroundColour(colours.lightGrey)
                 term.setTextColour(colours.grey)
                 term.clearLine()
 
-	if desx ~= 0 then
+                term.write("Go to frame: ")
-		if pfx ~= desx then
+                newframe = tonumber(readInput(2))
-			local temppfx,_ = getLeft(pfx,pfz)
+                if not newframe or newframe <= 0 then
-			if temppfx == desx then
+                        inMenu = false
-				sendPC("TL")
+                        return
-			elseif temppfx == -desx then
+                end
-				sendPC("TR")
+        elseif newframe <= 0 then return end
 
-				sendPC("TU")
+        if newframe > framecount then
                 for i=framecount+1,newframe do
                         frames[i] = {}
                         for y,line in pairs(frames[sFrame]) do
-		print("on the z axis")
+                                frames[i][y] = { }
-		if pfz ~= desz then
+                                for x,v in pairs(line) do
-			local _,temppfz = getLeft(pfx,pfz)
+                                        frames[i][y][x] = v
-			if temppfz == desz then
+                                end
-				sendPC("TL")
+                        end
-			elseif temppfz == -desz then
+                end
-				sendPC("TR")
+                framecount = newframe
         end
-				sendPC("TU")
+        sFrame = newframe
         inMenu = false
 end
 
 --[[Removes every frame leading after the frame passed in
         Params: frame:int the non-inclusive lower bounds of the delete
         Returns:nil
-	Params: nil
+
 local function removeFramesAfter(frame)
         inMenu = true
         if frame==framecount then return end
-	state = "active print"
+        drawMessage("Remove frames "..(frame+1).."/"..framecount.."? Y/N :")
-	if layering == "up" then
+        local answer = string.upper(readInput(1))
-		--An up layering starts our builder bot on the bottom left corner of our build
+
-		px,py,pz = leflim, 0, botlim + 1
+        if string.find(answer, string.upper("Y")) ~= 1 then
-		pfx,pfz = 0,-1
+                inMenu = false
                 return
-		--We move him forward and up a bit from his original position.
+        end
-		sendPC("FW")
+
-		sendPC("UP")
+        for i=frame+1, framecount do
-		--For each layer that needs to be completed, we go up by one each time
+                frames[i] = nil
-		for layers=1,#frames do
+        end
-			--We first decide if we're going forwards or back, depending on what side we're on
+        framecount = frame
-			local rowbot,rowtop,rowinc = nil,nil,nil
+        inMenu = false
-			if pz == botlim then
+
-				rowbot,rowtop,rowinc = botlim,toplim,-1
+
 --[[
-				rowbot,rowtop,rowinc = toplim,botlim,1
+                        Section: Printing Tools
 ]]--
 
-			for rows = rowbot,rowtop,rowinc do
+
-				--Then we decide if we're going left or right, depending on what side we're on
+        Params: curx:number = The facing on the X axis
-				local linebot,linetop,lineinc = nil,nil,nil
+                        curz:number = The facing on the Z axis
-				if px == leflim then
+                        hand:string = The hand of the axis ("right" or "left")
-					--Facing from the left side has to be easterly- it's changed here
+        Returns:number,number = the new facing on the X and Z axis after a left turn
-					turnToFace(1,0)
+
-					linebot,linetop,lineinc = leflim,riglim,1
+
         local hand = "left"
-					--Facing from the right side has to be westerly- it's changed here
+        if layering == "up" then hand = "right" end
-					turnToFace(-1,0)
+
-					linebot,linetop,lineinc = riglim,leflim,-1
+        if hand == "right" then
                 if curx == 1 then return 0,-1 end
                 if curx == -1 then return 0,1 end
-				for lines = linebot,linetop,lineinc do
+                if curz == 1 then return 1,0 end
-					--We move our turtle forward, placing the right material at each step
+                if curz == -1 then return -1,0 end
-					local material = frames[py][pz][px]
+        else
-					if material then
+                if curx == 1 then return 0,1 end
-						material = math.log10(frames[py][pz][px])/math.log10(2) + 1
+                if curx == -1 then return 0,-1 end
-						sendPC("SS", material)
+                if curz == 1 then return -1,0 end
-						sendPC("PD")
+                if curz == -1 then return 1,0 end
-					end
+        end
-					if lines ~= linetop then
+
-						sendPC("FW")
+
-					end
+
         Params: curx:number = The facing on the X axis
                         curz:number = The facing on the Z axis
-				--The printer then has to do a U-turn, depending on which way he's facing and
+                        hand:string = The hand of the axis ("right" or "left")
-				--which way he needs to go
+        Returns:number,number = the new facing on the X and Z axis after a right turn
-				local temppfx,temppfz = getLeft(pfx,pfz)
+
-				if temppfz == rowinc and rows ~= rowtop then
+
-					sendPC("TL")
+        local hand = "left"
-					sendPC("FW")
+        if layering == "up" then hand = "right" end
-					sendPC("TL")
+
-				elseif temppfz == -rowinc and rows ~= rowtop then
+        if hand == "right" then
-					sendPC("TR")
+                if curx == 1 then return 0,1 end
-					sendPC("FW")
+                if curx == -1 then return 0,-1 end
-					sendPC("TR")
+                if curz == 1 then return -1,0 end
                 if curz == -1 then return 1,0 end
         else
-			--Now at the end of a run he does a 180 and moves up to begin the next part of the print
+                if curx == 1 then return 0,-1 end
-			sendPC("TU")
+                if curx == -1 then return 0,1 end
-			if layers ~= #frames then
+                if curz == 1 then return 1,0 end
-				sendPC("UP")
+                if curz == -1 then return -1,0 end
         end
 end
-		--All done- now we head back to where we started.
+
-		if px ~= leflim then
+
-			turnToFace(-1,0)
+
-			while px ~= leflim do
+        printerList (for ID's) and printerNames (for names)
-				sendPC("FW")
+        Params: nil
         Returns:nil
 ]]--
-		if pz ~= botlim then
+
-			turnToFace(0,-1)
+        printerList = { }
-			while pz ~= botlim do
+        printerNames = { name = "Printers" }
-				sendPC("BK")
+        local oldState = state
         state = "Locating printers, please wait...   "
         drawCanvas()
-		turnToFace(0,-1)
+        drawInterface()
-		sendPC("BK")
+        state = oldState
-		while py > 0 do
+
-			sendPC("DW")
+        local modemOpened = false
         for k,v in pairs(rs.getSides()) do
                 if peripheral.isPresent(v) and peripheral.getType(v) == "modem" then
-		--The front facing is at the top-left corner, facing south not north
+                        rednet.open(v)
-		px,py,pz = leflim, botlim, 1
+                        modemOpened = true
-		pfx,pfz = 0,1
+                        break
-		--We move the printer to the last layer- he prints from the back forwards
+                end
-		while pz < #frames do
+        end
-			sendPC("FW")
+
         if not modemOpened then
                 displayConfirmDialogue("Modem not found!", "No modem peripheral. Must have network modem to locate printers.")
-		--For each layer in the frame we build our wall, the move back
+                return false
-		for layers = 1,#frames do
+        end
-			--We first decide if we're going left or right based on our position
+
-			local rowbot,rowtop,rowinc = nil,nil,nil
+        rednet.broadcast("$3DPRINT IDENTIFY")
-			if px == leflim then
+
-				rowbot,rowtop,rowinc = leflim,riglim,1
+        while true do
                 local id, msg = rsTimeReceive(1)
-				rowbot,rowtop,rowinc = riglim,leflim,-1
+
                 if not id then break end
                 if string.find(msg, "$3DPRINT IDACK") == 1 then
-			for rows = rowbot,rowtop,rowinc do
+                        msg = string.gsub(msg, "$3DPRINT IDACK ", "")
-				--Then we decide if we're going up or down, depending on our given altitude
+                        table.insert(printerList, id)
-				local linebot,linetop,lineinc = nil,nil,nil
+                        table.insert(printerNames, msg)
-				if py == botlim then
+                end
-					linebot,linetop,lineinc = botlim,toplim,-1
+        end
 
-					linebot,linetop,lineinc = toplim,botlim,1
+        if #printerList == 0 then
                 displayConfirmDialogue("Printers not found!", "No active printers found in proximity of this computer.")
                 return false
-				for lines = linebot,linetop,lineinc do
+        else
-				--We move our turtle up/down, placing the right material at each step
+                return true
-					local material = frames[pz][py][px]
+        end
-					if material then
+
-						material = math.log10(frames[pz][py][px])/math.log10(2) + 1
+
-						sendPC("SS", material)
+
-						sendPC("PF")
+        Params: command:string the command to send
-					end
+                        param:string a parameter to send, if any
-					if lines ~= linetop then
+        Returns:nil
-						if lineinc == 1 then sendPC("DW")
+
-						else sendPC("UP") end
+
-					end
+        local msg = "$PC "..command
         if param then msg = msg.." "..param end
-
+        rednet.send(printerList[selectedPrinter], msg)
-				if rows ~= rowtop then
+
-					turnToFace(rowinc,0)
+        while true do
-					sendPC("FW")
+                local id,key = rsTimeReceive()
-					turnToFace(0,1)
+                if id == printerList[selectedPrinter] then
                         if key == "$3DPRINT ACK" then
                                 break
                         elseif key == "$3DPRINT DEP" then
-			if layers ~= #frames then
+                                displayConfirmDialogue("Printer Empty", "The printer has exhasted a material. Please refill slot "..param..
-				sendPC("TU")
+                                        ", and click this message when ready to continue.")
-				sendPC("FW")
+                                rednet.send(printerList[selectedPrinter], msg)
-				sendPC("TU")
+                        elseif key == "$3DPRINT OOF" then
                                 displayConfirmDialogue("Printer Out of Fuel", "The printer has no fuel. Please replace the material "..
                                         "in slot 1 with a fuel source, then click this message.")
-		--He's easy to reset
+                                rednet.send(printerList[selectedPrinter], "$PC SS 1")
-		while px ~= leflim do
+                                id,key = rsTimeReceive()
-			turnToFace(-1,0)
+                                rednet.send(printerList[selectedPrinter], "$PC RF")
-			sendPC("FW")
+                                id,key = rsTimeReceive()
                                 rednet.send(printerList[selectedPrinter], msg)
-		turnToFace(0,1)
+                        end
                 end
         end
-	sendPC("DE")
+
         --Changes to position are handled after the event has been successfully completed
-	displayConfirmDialogue("Print complete", "The 3D print was successful.")
+        if command == "FW" then
                 px = px + pfx
                 pz = pz + pfz
         elseif command == "BK" then
-			Section: Interface
+                px = px - pfx
                 pz = pz - pfz
         elseif command == "UP" then
                 if layering == "up" then
                         py = py + 1
-	Returns:boolean true if printing was started, false otherwse
+                else
                         py = py - 1
                 end
-	calculateMaterials()
+        elseif command == "DW" then
-	--There's nothing on canvas yet!
+                if layering == "up" then
-	if not botlim then
+                        py = py - 1
-		displayConfirmDialogue("Cannot Print Empty Canvas", "There is nothing on canvas that "..
+                else
-				"can be printed, and the operation cannot be completed.")
+                        py = py + 1
-		return false
+                end
         elseif command == "TL" then
-	--No printers nearby
+                pfx,pfz = getLeft(pfx,pfz)
-	if not locatePrinters() then
+        elseif command == "TR" then
-		return false
+                pfx,pfz = getRight(pfx,pfz)
         elseif command == "TU" then
                 pfx = -pfx
-	layering = "up"
+                pfz = -pfz
-	requirementsDisplayed = false
+        end
-	selectedPrinter = 1
+
         drawCanvas()
-		drawCanvas()
+        drawInterface()
 end
-		for i=1,10 do
+
-			term.setCursorPos(1,i)
+
-			term.clearLine()
+        Params: desx:number = the normalized x direction to face
                         desz:number = the normalized z direction to face
-		drawInterface()
+        Returns:nil
 ]]--
 local function turnToFace(desx,desz)
         if desx ~= 0 then
-		local msg = "3D Printing"
+                if pfx ~= desx then
-		term.setCursorPos(w/2-#msg/2 - 2, 1)
+                        local temppfx,_ = getLeft(pfx,pfz)
-		term.write(msg)
+                        if temppfx == desx then
-		term.setBackgroundColour(colours.grey)
+                                sendPC("TL")
-		term.setTextColour(colours.lightGrey)
+                        elseif temppfx == -desx then
-		if(requirementsDisplayed) then
+                                sendPC("TR")
-			msg = "Count:"
+                        else
                                 sendPC("TU")
-			msg = " Slot:"
+                        end
                 end
-		term.setCursorPos(w-3-#msg, 1)
+        else
-		term.write(msg)
+                print("on the z axis")
                 if pfz ~= desz then
                         local _,temppfz = getLeft(pfx,pfz)
                         if temppfz == desz then
-		term.setCursorPos(7, 2)
+                                sendPC("TL")
-		term.write("Layering")
+                        elseif temppfz == -desz then
-		drawPictureTable(layerUpIcon, 3, 3, colours.white)
+                                sendPC("TR")
-		drawPictureTable(layerForwardIcon, 12, 3, colours.white)
+                        else
-		if layering == "up" then
+                                sendPC("TU")
-			term.setBackgroundColour(colours.red)
+                        end
                 end
         end
 end
-		term.setCursorPos(3, 9)
+
-		term.write("Upwards")
+
-		if layering == "forward" then
+        Params: nil
-			term.setBackgroundColour(colours.red)
+        Returns:nil
 ]]--
 local function performPrint()
         state = "active print"
-		term.setCursorPos(12, 9)
+        if layering == "up" then
-		term.write("Forward")
+                --An up layering starts our builder bot on the bottom left corner of our build
                 px,py,pz = leflim, 0, botlim + 1
                 pfx,pfz = 0,-1
 
-		term.setCursorPos(31, 2)
+                --We move him forward and up a bit from his original position.
-		term.write("Printer ID")
+                sendPC("FW")
-		term.setCursorPos(33, 3)
+                sendPC("UP")
-		if #printerList > 1 then
+                --For each layer that needs to be completed, we go up by one each time
                 for layers=1,#frames do
                         --We first decide if we're going forwards or back, depending on what side we're on
                         local rowbot,rowtop,rowinc = nil,nil,nil
                         if pz == botlim then
                                 rowbot,rowtop,rowinc = botlim,toplim,-1
-		term.write(" "..printerNames[selectedPrinter].." ")
+                        else
                                 rowbot,rowtop,rowinc = toplim,botlim,1
-		term.setBackgroundColour(colours.grey)
+                        end
-		term.setTextColour(colours.lightGrey)
+
-		term.setCursorPos(25, 10)
+                        for rows = rowbot,rowtop,rowinc do
-		term.write(" Cancel ")
+                                --Then we decide if we're going left or right, depending on what side we're on
-		term.setCursorPos(40, 10)
+                                local linebot,linetop,lineinc = nil,nil,nil
-		term.write(" Print ")
+                                if px == leflim then
                                         --Facing from the left side has to be easterly- it's changed here
-		local id, p1, p2, p3 = os.pullEvent()
+                                        turnToFace(1,0)
                                         linebot,linetop,lineinc = leflim,riglim,1
-		if id == "timer" then
+                                else
-			updateTimer(p1)
+                                        --Facing from the right side has to be westerly- it's changed here
                                         turnToFace(-1,0)
-			--Layering Buttons
+                                        linebot,linetop,lineinc = riglim,leflim,-1
-			if p2 >= 3 and p2 <= 9 and p3 >= 3 and p3 <= 9 then
+                                end
-				layering = "up"
+
-			elseif p2 >= 12 and p2 <= 18 and p3 >= 3 and p3 <= 9 then
+                                for lines = linebot,linetop,lineinc do
-				layering = "forward"
+                                        --We move our turtle forward, placing the right material at each step
-			--Count/Slot
+                                        local material = frames[py][pz][px]
-			elseif p2 >= w - #msg - 3 and p2 <= w - 3 and p3 == 1 then
+                                        if material then
-				requirementsDisplayed = not requirementsDisplayed
+                                                material = math.log10(frames[py][pz][px])/math.log10(2) + 1
-			--Printer ID
+                                                sendPC("SS", material)
-			elseif p2 >= 33 and p2 <= 33 + #printerNames[selectedPrinter] and p3 == 3 and #printerList > 1 then
+                                                sendPC("PD")
-				local chosenName = displayDropDown(33, 3, printerNames)
+                                        end
-				for i=1,#printerNames do
+                                        if lines ~= linetop then
-					if printerNames[i] == chosenName then
+                                                sendPC("FW")
-						selectedPrinter = i
+                                        end
-						break;
+                                end
-					end
+
                                 --The printer then has to do a U-turn, depending on which way he's facing and
-			--Print and Cancel
+                                --which way he needs to go
-			elseif p2 >= 25 and p2 <= 32 and p3 == 10 then
+                                local temppfx,temppfz = getLeft(pfx,pfz)
-				break
+                                if temppfz == rowinc and rows ~= rowtop then
-			elseif p2 >= 40 and p2 <= 46 and p3 == 10 then
+                                        sendPC("TL")
-				rednet.send(printerList[selectedPrinter], "$3DPRINT ACTIVATE")
+                                        sendPC("FW")
-				ready = false
+                                        sendPC("TL")
-				while true do
+                                elseif temppfz == -rowinc and rows ~= rowtop then
-					local id,msg = rsTimeReceive(10)
+                                        sendPC("TR")
-
+                                        sendPC("FW")
-					if id == printerList[selectedPrinter] and msg == "$3DPRINT ACTACK" then
+                                        sendPC("TR")
-						ready = true
+                                end
-						break
+                        end
-					end
+                        --Now at the end of a run he does a 180 and moves up to begin the next part of the print
                         sendPC("TU")
-				if ready then
+                        if layers ~= #frames then
-					performPrint()
+                                sendPC("UP")
-					break
+                        end
                 end
-					displayConfirmDialogue("Printer Didn't Respond", "The printer didn't respond to the activation command. Check to see if it's online")
+                --All done- now we head back to where we started.
                 if px ~= leflim then
                         turnToFace(-1,0)
                         while px ~= leflim do
                                 sendPC("FW")
-	state = "paint"
+                        end
                 end
                 if pz ~= botlim then
                         turnToFace(0,-1)
-	any necessary changes in logic involved in that.
+                        while pz ~= botlim do
-	Params: mode:string = the name of the mode to change to
+                                sendPC("BK")
                         end
                 end
                 turnToFace(0,-1)
-	if not mode or mode == "" then return
+                sendPC("BK")
                 while py > 0 do
-	elseif mode == "help" then
+                        sendPC("DW")
-		drawHelpScreen()
+                end
         else
-	elseif mode == "blueprint on" then
+                --The front facing is at the top-left corner, facing south not north
-		blueprint = true
+                px,py,pz = leflim, botlim, 1
-		ddModes[2][3] = "blueprint off"
+                pfx,pfz = 0,1
                 --We move the printer to the last layer- he prints from the back forwards
-	elseif mode == "blueprint off" then
+                while pz < #frames do
-		blueprint = false
+                        sendPC("FW")
-		ddModes[2][3] = "blueprint on"
+                end
 
-	elseif mode == "layers on" then
+                --For each layer in the frame we build our wall, the move back
-		layerDisplay = true
+                for layers = 1,#frames do
-		ddModes[2][4] = "layers off"
+                        --We first decide if we're going left or right based on our position
                         local rowbot,rowtop,rowinc = nil,nil,nil
-	elseif mode == "layers off" then
+                        if px == leflim then
-		layerDisplay = false
+                                rowbot,rowtop,rowinc = leflim,riglim,1
-		ddModes[2][4] = "layers on"
+                        else
                                 rowbot,rowtop,rowinc = riglim,leflim,-1
-	elseif mode == "direction on" then
+                        end
-		printDirection = true
+
-		ddModes[2][5] = "direction off"
+                        for rows = rowbot,rowtop,rowinc do
                                 --Then we decide if we're going up or down, depending on our given altitude
-	elseif mode == "direction off" then
+                                local linebot,linetop,lineinc = nil,nil,nil
-		printDirection = false
+                                if py == botlim then
-		ddModes[2][5] = "direction on"
+                                        linebot,linetop,lineinc = botlim,toplim,-1
                                 else
-	elseif mode == "go to" then
+                                        linebot,linetop,lineinc = toplim,botlim,1
-		changeFrame()
+                                end
 
-	elseif mode == "remove" then
+                                for lines = linebot,linetop,lineinc do
-		removeFramesAfter(sFrame)
+                                --We move our turtle up/down, placing the right material at each step
                                         local material = frames[pz][py][px]
-	elseif mode == "play" then
+                                        if material then
-		playAnimation()
+                                                material = math.log10(frames[pz][py][px])/math.log10(2) + 1
                                                 sendPC("SS", material)
-	elseif mode == "copy" then
+                                                sendPC("PF")
-		if selectrect and selectrect.x1 ~= selectrect.x2 then
+                                        end
-			copyToBuffer(false)
+                                        if lines ~= linetop then
                                                 if lineinc == 1 then sendPC("DW")
                                                 else sendPC("UP") end
-	elseif mode == "cut" then
+                                        end
-		if selectrect and selectrect.x1 ~= selectrect.x2 then
+                                end
-			copyToBuffer(true)
+
                                 if rows ~= rowtop then
                                         turnToFace(rowinc,0)
-	elseif mode == "paste" then
+                                        sendPC("FW")
-		if selectrect and selectrect.x1 ~= selectrect.x2 then
+                                        turnToFace(0,1)
-			copyFromBuffer(false)
+                                end
                         end
 
-	elseif mode == "hide" then
+                        if layers ~= #frames then
-		selectrect = nil
+                                sendPC("TU")
-		if state == "select" then state = "corner select" end
+                                sendPC("FW")
                                 sendPC("TU")
-	elseif mode == "alpha to left" then
+                        end
-		if lSel then alphaC = lSel end
+                end
                 --He's easy to reset
-	elseif mode == "alpha to right" then
+                while px ~= leflim do
-		if rSel then alphaC = rSel end
+                        turnToFace(-1,0)
                         sendPC("FW")
-	elseif mode == "record" then
+                end
-		record = not record
+                turnToFace(0,1)
         end
-	elseif mode == "clear" then
+
-		if state=="select" then buffer = nil
+        sendPC("DE")
-		else clearImage() end
+
         displayConfirmDialogue("Print complete", "The 3D print was successful.")
-	elseif mode == "select" then
+
-		if state=="corner select" or state=="select" then
+
-			state = "paint"
+
-		elseif selectrect and selectrect.x1 ~= selectrect.x2 then
+                        Section: Interface
-			state = "select"
+
 
-			state = "corner select"
+
         Params: none
         Returns:boolean true if printing was started, false otherwse
-	elseif mode == "print" then
+
-		state = "print"
+
-		runPrintInterface()
+        calculateMaterials()
-		state = "paint"
+        --There's nothing on canvas yet!
         if not botlim then
-	elseif mode == "save" then
+                displayConfirmDialogue("Cannot Print Empty Canvas", "There is nothing on canvas that "..
-		if animated then saveNFA(sPath)
+                                "can be printed, and the operation cannot be completed.")
-		elseif textEnabled then saveNFT(sPath)
+                return false
-		else saveNFP(sPath) end
+        end
         --No printers nearby
-	elseif mode == "exit" then
+        if not locatePrinters() then
-		isRunning = false
+                return false
         end
-	elseif mode ~= state then state = mode
+
-	else state = "paint"
+        layering = "up"
         requirementsDisplayed = false
         selectedPrinter = 1
         while true do
                 drawCanvas()
                 term.setBackgroundColour(colours.lightGrey)
-	painting to the canvas and general selections are done here.
+                for i=1,10 do
                         term.setCursorPos(1,i)
                         term.clearLine()
                 end
                 drawInterface()
-	recttimer = os.startTimer(0.5)
+                term.setBackgroundColour(colours.lightGrey)
-	while isRunning do
+                term.setTextColour(colours.black)
-		drawCanvas()
+
-		drawInterface()
+                local msg = "3D Printing"
                 term.setCursorPos(w/2-#msg/2 - 2, 1)
-		if state == "text" then
+                term.write(msg)
-			term.setCursorPos(textCurX - sx, textCurY - sy)
+                term.setBackgroundColour(colours.grey)
-			term.setCursorBlink(true)
+                term.setTextColour(colours.lightGrey)
                 if(requirementsDisplayed) then
                         msg = "Count:"
                 else
-			term.setCursorBlink(false)
+                        msg = " Slot:"
-		if id=="timer" then
+                end
-			updateTimer(p1)
+                term.setCursorPos(w-3-#msg, 1)
-		elseif id=="mouse_click" or id=="mouse_drag" then
+                term.write(msg)
-			if p2 >=w-1 and p3 < #column+1 then
+                term.setBackgroundColour(colours.lightGrey)
-				if p1==1 then lSel = column[p3]
+                term.setTextColour(colours.black)
-				else rSel = column[p3] end
+
-			elseif p2 >=w-1 and p3==#column+1 then
+                term.setCursorPos(7, 2)
-				if p1==1 then lSel = nil
+                term.write("Layering")
-				else rSel = nil end
+                drawPictureTable(layerUpIcon, 3, 3, colours.white)
-			elseif p2==w-1 and p3==h and animated then
+                drawPictureTable(layerForwardIcon, 12, 3, colours.white)
-				changeFrame(sFrame-1)
+                if layering == "up" then
-			elseif p2==w and p3==h and animated then
+                        term.setBackgroundColour(colours.red)
-				changeFrame(sFrame+1)
+                else
-			elseif p2 < w-10 and p3==h then
+                        term.setBackgroundColour(colours.lightGrey)
-				local sel = displayDropDown(1, h-1, ddModes)
+                end
-				performSelection(sel)
+                term.setCursorPos(3, 9)
-			elseif p2 < w-1 and p3 <= h-1 then
+                term.write("Upwards")
-				if state=="pippette" then
+                if layering == "forward" then
-					if p1==1 then
+                        term.setBackgroundColour(colours.red)
-						if frames[sFrame][p3+sy] and frames[sFrame][p3+sy][p2+sx] then
+                else
-							lSel = frames[sFrame][p3+sy][p2+sx]
+                        term.setBackgroundColour(colours.lightGrey)
-						end
+                end
-					elseif p1==2 then
+                term.setCursorPos(12, 9)
-						if frames[sFrame][p3+sy] and frames[sFrame][p3+sy][p2+sx] then
+                term.write("Forward")
-							rSel = frames[sFrame][p3+sy][p2+sx]
+
-						end
+                term.setBackgroundColour(colours.lightGrey)
-					end
+                term.setTextColour(colours.black)
-				elseif state=="move" then
+                term.setCursorPos(31, 2)
-					updateImageLims(record)
+                term.write("Printer ID")
-					moveImage(p2,p3)
+                term.setCursorPos(33, 3)
-				elseif state=="flood" then
+                if #printerList > 1 then
-					if p1 == 1 and lSel and frames[sFrame][p3+sy]  then
+                        term.setBackgroundColour(colours.grey)
-						floodFill(p2,p3,frames[sFrame][p3+sy][p2+sx],lSel)
+                        term.setTextColour(colours.lightGrey)
-					elseif p1 == 2 and rSel and frames[sFrame][p3+sy] then
+                else
-						floodFill(p2,p3,frames[sFrame][p3+sy][p2+sx],rSel)
+                        term.setTextColour(colours.red)
-					end
+                end
-				elseif state=="corner select" then
+                term.write(" "..printerNames[selectedPrinter].." ")
-					if not selectrect then
+
-						selectrect = { x1=p2+sx, x2=p2+sx, y1=p3+sy, y2=p3+sy }
+                term.setBackgroundColour(colours.grey)
-					elseif selectrect.x1 ~= p2+sx and selectrect.y1 ~= p3+sy then
+                term.setTextColour(colours.lightGrey)
-						if p2+sx<selectrect.x1 then selectrect.x1 = p2+sx
+                term.setCursorPos(25, 10)
-						else selectrect.x2 = p2+sx end
+                term.write(" Cancel ")
-
+                term.setCursorPos(40, 10)
-						if p3+sy<selectrect.y1 then selectrect.y1 = p3+sy
+                term.write(" Print ")
-						else selectrect.y2 = p3+sy end
+
-
+                local id, p1, p2, p3 = os.pullEvent()
-						state = "select"
+
-					end
+                if id == "timer" then
-				elseif state=="textpaint" then
+                        updateTimer(p1)
-					local paintCol = lSel
+                elseif id == "mouse_click" then
-					if p1 == 2 then paintCol = rSel end
+                        --Layering Buttons
-					if frames[sFrame].textcol[p3+sy] then
+                        if p2 >= 3 and p2 <= 9 and p3 >= 3 and p3 <= 9 then
-						frames[sFrame].textcol[p3+sy][p2+sx] = paintCol
+                                layering = "up"
-					end
+                        elseif p2 >= 12 and p2 <= 18 and p3 >= 3 and p3 <= 9 then
-				elseif state=="text" then
+                                layering = "forward"
-					textCurX = p2 + sx
+                        --Count/Slot
-					textCurY = p3 + sy
+                        elseif p2 >= w - #msg - 3 and p2 <= w - 3 and p3 == 1 then
-				elseif state=="select" then
+                                requirementsDisplayed = not requirementsDisplayed
-					if p1 == 1 then
+                        --Printer ID
-						local swidth = selectrect.x2 - selectrect.x1
+                        elseif p2 >= 33 and p2 <= 33 + #printerNames[selectedPrinter] and p3 == 3 and #printerList > 1 then
-						local sheight = selectrect.y2 - selectrect.y1
+                                local chosenName = displayDropDown(33, 3, printerNames)
-
+                                for i=1,#printerNames do
-						selectrect.x1 = p2 + sx
+                                        if printerNames[i] == chosenName then
-						selectrect.y1 = p3 + sy
+                                                selectedPrinter = i
-						selectrect.x2 = p2 + swidth + sx
+                                                break;
-						selectrect.y2 = p3 + sheight + sy
+                                        end
-					elseif p1 == 2 and p2 < w-2 and p3 < h-1 then
+                                end
-						inMenu = true
+                        --Print and Cancel
-						local sel = displayDropDown(p2, p3, srModes)
+                        elseif p2 >= 25 and p2 <= 32 and p3 == 10 then
-						inMenu = false
+                                break
-						performSelection(sel)
+                        elseif p2 >= 40 and p2 <= 46 and p3 == 10 then
-					end
+                                rednet.send(printerList[selectedPrinter], "$3DPRINT ACTIVATE")
                                 ready = false
-					local f,l = sFrame,sFrame
+                                while true do
-					if record then f,l = 1,framecount end
+                                        local id,msg = rsTimeReceive(10)
-					local bwidth = 0
+
-					if state == "brush" then bwidth = brushsize-1 end
+                                        if id == printerList[selectedPrinter] and msg == "$3DPRINT ACTACK" then
                                                 ready = true
-					for i=f,l do
+                                                break
-						for x = math.max(1,p2+sx-bwidth),p2+sx+bwidth do
+                                        end
-							for y = math.max(1,p3+sy-bwidth), p3+sy+bwidth do
+                                end
-								if math.abs(x - (p2+sx)) + math.abs(y - (p3+sy)) <= bwidth then
+                                if ready then
-									if not frames[i][y] then frames[i][y] = {} end
+                                        performPrint()
-									if p1==1 then frames[i][y][x] = lSel
+                                        break
-									else frames[i][y][x] = rSel end
+                                else
-
+                                        displayConfirmDialogue("Printer Didn't Respond", "The printer didn't respond to the activation command. Check to see if it's online")
-									if textEnabled then
+                                end
-										if not frames[i].text[y] then frames[i].text[y] = { } end
+                        end
-										if not frames[i].textcol[y] then frames[i].textcol[y] = { } end
+                end
         end
         state = "paint"
 end
-						end
+
-					end
+--[[Performs a legacy save. When the dropdown menu is unavailable, it requests the user to save
 	or exit using keyboard shortcuts rather than selecting a menu option from the dropdown.
 	Pressing the control key again will cancel the save operation.
-		elseif id=="char" then
+
-			if state=="text" then
+	Returns:string = the selection made
-				if not frames[sFrame][textCurY] then frames[sFrame][textCurY] = { } end
+
-				if not frames[sFrame].text[textCurY] then frames[sFrame].text[textCurY] = { } end
+local function performLegacySaveExit()
-				if not frames[sFrame].textcol[textCurY] then frames[sFrame].textcol[textCurY] = { } end
+	local saveMsg = "(S)ave/(E)xit?"
 	if w < #saveMsg then saveMsg = "S/E?" end
-				if rSel then frames[sFrame][textCurY][textCurX] = rSel end
+
-				if lSel then
+
-					frames[sFrame].text[textCurY][textCurX] = p1
+
-					frames[sFrame].textcol[textCurY][textCurX] = lSel
+
 	term.clearLine()
-					frames[sFrame].text[textCurY][textCurX] = " "
+	term.write(saveMsg)
-					frames[sFrame].textcol[textCurY][textCurX] = rSel
+
 	while true do
 		local id,val = os.pullEvent()
-				textCurX = textCurX+1
+		if id == "timer" then updateTimer(val)
-				if textCurX > w + sx - 2 then sx = textCurX - w + 2 end
+		elseif id == "key" then
-			elseif tonumber(p1) then
+			if val == keys.s then return "save"
-				if state=="brush" and tonumber(p1) > 1 then
+			elseif val == keys.e then
-					brushsize = tonumber(p1)
+				--Get rid of the extra event
-				elseif animated and tonumber(p1) > 0 then
+				os.pullEvent("char")
-					changeFrame(tonumber(p1))
+				return "exit"
 			elseif val == keys.leftCtrl then return nil
 			end
-		elseif id=="key" then
+
-			--Text needs special handlers (all other keyboard shortcuts are of course reserved for typing)
+
-			if state=="text" then
+
-				if p1==keys.backspace and textCurX > 1 then
+
-					textCurX = textCurX-1
+
-					if frames[sFrame].text[textCurY] then
+        any necessary changes in logic involved in that.
-						frames[sFrame].text[textCurY][textCurX] = nil
+        Params: mode:string = the name of the mode to change to
-						frames[sFrame].textcol[textCurY][textCurX] = nil
+        Returns:nil
-					end
+
-					if textCurX < sx then sx = textCurX end
+
-				elseif p1==keys.left and textCurX > 1 then
+        if not mode or mode == "" then return
-					textCurX = textCurX-1
+
-					if textCurX-1 < sx then sx = textCurX-1 end
+        elseif mode == "help" and helpAvailable then
-				elseif p1==keys.right then
+                drawHelpScreen()
-					textCurX = textCurX+1
+
-					if textCurX > w + sx - 2 then sx = textCurX - w + 2 end
+        elseif mode == "blueprint on" then
-				elseif p1==keys.up and textCurY > 1 then
+                blueprint = true
-					textCurY = textCurY-1
+				for i=1,#ddModes[2] do if ddModes[2][i] == "blueprint on" then
-					if textCurY-1 < sy then sy = textCurY-1 end
+					ddModes[2][i] = "blueprint off"
-				elseif p1==keys.down then
+				end end
-					textCurY = textCurY+1
+
-					if textCurY > h + sy - 1 then sy = textCurY - h + 1 end
+        elseif mode == "blueprint off" then
                 blueprint = false
 				for i=1,#ddModes[2] do if ddModes[2][i] == "blueprint off" then
-			elseif p1==keys.leftCtrl then
+					ddModes[2][i] = "blueprint on"
-				local sel = displayDropDown(1, h-1, ddModes[#ddModes])
+				end end
-				performSelection(sel)
+
-			elseif p1==keys.leftAlt then
+        elseif mode == "layers on" then
-				local sel = displayDropDown(1, h-1, ddModes[1])
+                layerDisplay = true
-				performSelection(sel)
+				for i=1,#ddModes[2] do if ddModes[2][i] == "layers on" then
-			elseif p1==keys.h then
+					ddModes[2][i] = "layers off"
-				performSelection("help")
+				end end
-			elseif p1==keys.x then
+
-				performSelection("cut")
+        elseif mode == "layers off" then
-			elseif p1==keys.c then
+                layerDisplay = false
-				performSelection("copy")
+				for i=1,#ddModes[2] do if ddModes[2][i] == "layers off" then
-			elseif p1==keys.v then
+					ddModes[2][i] = "layers on"
-				performSelection("paste")
+				end end
-			elseif p1==keys.z then
+
-				performSelection("clear")
+        elseif mode == "direction on" then
-			elseif p1==keys.s then
+                printDirection = true
-				performSelection("select")
+				for i=1,#ddModes[2] do if ddModes[2][i] == "direction on" then
-			elseif p1==keys.tab then
+					ddModes[2][i] = "direction off"
-				performSelection("hide")
+				end end
-			elseif p1==keys.q then
+
-				performSelection("alpha to left")
+        elseif mode == "direction off" then
-			elseif p1==keys.w then
+                printDirection = false
-				performSelection("alpha to right")
+				for i=1,#ddModes[2] do if ddModes[2][i] == "direction off" then
-			elseif p1==keys.f then
+					ddModes[2][i] = "direction on"
-				performSelection("flood")
+				end end
-			elseif p1==keys.b then
+
-				performSelection("brush")
+		elseif mode == "hide interface" then
-			elseif p1==keys.m then
+				interfaceHidden = true
-				performSelection("move")
+
-			elseif p1==keys.backslash and animated then
+		elseif mode == "show interface" then
-				performSelection("record")
+				interfaceHidden = false
-			elseif p1==keys.p then
+
-				performSelection("pippette")
+        elseif mode == "go to" then
-			elseif p1==keys.g and animated then
+                changeFrame()
-				performSelection("go to")
+
-			elseif p1==keys.period and animated then
+        elseif mode == "remove" then
-				changeFrame(sFrame+1)
+                removeFramesAfter(sFrame)
-			elseif p1==keys.comma and animated then
+
-				changeFrame(sFrame-1)
+        elseif mode == "play" then
-			elseif p1==keys.r and animated then
+                playAnimation()
-				performSelection("remove")
+
-			elseif p1==keys.space and animated then
+        elseif mode == "copy" then
-				performSelection("play")
+                if selectrect and selectrect.x1 ~= selectrect.x2 then
-			elseif p1==keys.t and textEnabled then
+                        copyToBuffer(false)
-				performSelection("text")
+                end
-				sleep(0.01)
+
-			elseif p1==keys.y and textEnabled then
+        elseif mode == "cut" then
-				performSelection("textpaint")
+                if selectrect and selectrect.x1 ~= selectrect.x2 then
-			elseif p1==keys.left then
+                        copyToBuffer(true)
-				if state == "move" and toplim then
+                end
-					updateImageLims(record)
+
-					if toplim and leflim then
+        elseif mode == "paste" then
-						moveImage(leflim-1,toplim)
+                if selectrect and selectrect.x1 ~= selectrect.x2 then
-					end
+                        copyFromBuffer(false)
-				elseif state=="select" and selectrect.x1 > 1 then
+                end
-					selectrect.x1 = selectrect.x1-1
+
-					selectrect.x2 = selectrect.x2-1
+        elseif mode == "hide" then
-				elseif sx > 0 then sx=sx-1 end
+                selectrect = nil
-			elseif p1==keys.right then
+                if state == "select" then state = "corner select" end
-				if state == "move" then
+
-					updateImageLims(record)
+        elseif mode == "alpha to left" then
-					if toplim and leflim then
+                if lSel then alphaC = lSel end
-						moveImage(leflim+1,toplim)
+
-					end
+        elseif mode == "alpha to right" then
-				elseif state=="select" then
+                if rSel then alphaC = rSel end
-					selectrect.x1 = selectrect.x1+1
+
-					selectrect.x2 = selectrect.x2+1
+        elseif mode == "record" then
-				else sx=sx+1 end
+                record = not record
-			elseif p1==keys.up then
+
-				if state == "move" then
+        elseif mode == "clear" then
-					updateImageLims(record)
+                if state=="select" then buffer = nil
-					if toplim and leflim then
+                else clearImage() end
-						moveImage(leflim,toplim-1)
+
-					end
+        elseif mode == "select" then
-				elseif state=="select" and selectrect.y1 > 1 then
+                if state=="corner select" or state=="select" then
-					selectrect.y1 = selectrect.y1-1
+                        state = "paint"
-					selectrect.y2 = selectrect.y2-1
+                elseif selectrect and selectrect.x1 ~= selectrect.x2 then
-				elseif sy > 0 then sy=sy-1 end
+                        state = "select"
-			elseif p1==keys.down then
+                else
-				if state == "move" then
+                        state = "corner select"
-					updateImageLims(record)
+                end
-					if toplim and leflim then
+
-						moveImage(leflim,toplim+1)
+        elseif mode == "print" then
-					end
+                state = "print"
-				elseif state=="select" then
+                runPrintInterface()
-					selectrect.y1 = selectrect.y1+1
+                state = "paint"
-					selectrect.y2 = selectrect.y2+1
+
-				else sy=sy+1 end
+        elseif mode == "save" then
                 if animated then saveNFA(sPath)
                 elseif textEnabled then saveNFT(sPath)
                 else saveNFP(sPath) end
 
         elseif mode == "exit" then
                 isRunning = false
-			Section: Main
+
         elseif mode ~= state then state = mode
         else state = "paint"
         end
-	print("For colour computers only")
+
 
 --[[The main function of the program, reads and handles all events and updates them accordingly. Mode changes,
         painting to the canvas and general selections are done here.
         Params: none
         Returns:nil
 ]]--
 local function handleEvents()
         recttimer = os.startTimer(0.5)
-if tArgs[ca] == "-a" then
+        while isRunning do
-	animated = true
+                drawCanvas()
                 if not interfaceHidden then drawInterface() end
 
                 if state == "text" then
-if tArgs[ca] == "-t" then
+                        term.setCursorPos(textCurX - sx, textCurY - sy)
-	textEnabled = true
+                        term.setCursorBlink(true)
                 end
 
                 local id,p1,p2,p3 = os.pullEvent()
                 term.setCursorBlink(false)
-	print("Usage: npaintpro [-a,-t] <path>")
+                if id=="timer" then
                         updateTimer(p1)
                 elseif (id=="mouse_click" or id=="mouse_drag") and not interfaceHidden then
                         if p2 >=w-1 and p3 < #column+1 then
---Yeah you can't have animated text files YET... I haven't supported that, maybe later?
+								local off = 0
 								local cansel = true
-	print("No support for animated text files- cannot have both -a and -t")
+								if h < #column + 2 then
 									if p3 == 1 then
 										if columnoffset > 0 then columnoffset = columnoffset-1 end
-sPath = shell.resolve(tArgs[ca])
+										cansel = false
-local bReadOnly = fs.isReadOnly(sPath)
+									elseif p3 == h-2 then
 										if columnoffset < #column-(h-4)+1 then columnoffset = columnoffset+1 end
-	if fs.isDir(sPath) then
+										cansel = false
-		print("Cannot edit a directory.")
+									else
 										off = columnoffset - 1
-	elseif string.find(sPath, ".nfp") ~= #sPath-3 and string.find(sPath, ".nfa") ~= #sPath-3 and
+
-			string.find(sPath, ".nft") ~= #sPath-3 then
+
-		print("Can only edit .nfp, .nft and .nfa files:",string.find(sPath, ".nfp"),#sPath-3)
+								--This rather handily accounts for the nil case (p3+off=#column+1)
 								if p1==1 and cansel then lSel = column[p3+off]
                                 elseif p1==2 and cansel then rSel = column[p3+off] end
                         elseif p2 >=w-1 and p3==#column+1 then
-	if string.find(sPath, ".nfa") == #sPath-3 then
+                                if p1==1 then lSel = nil
-		animated = true
+                                else rSel = nil end
                         elseif p2==w-1 and p3==h and animated then
                                 changeFrame(sFrame-1)
-	if string.find(sPath, ".nft") == #sPath-3 then
+                        elseif p2==w and p3==h and animated then
-		textEnabled = true
+                                changeFrame(sFrame+1)
-	end
+                        elseif p2 <= #ddModes.name + 2 and p3==h and mainAvailable then
                                 local sel = displayDropDown(1, h-1, ddModes)
-	if string.find(sPath, ".nfp") == #sPath-3 and animated then
+                                performSelection(sel)
-		print("Convert to nfa? Y/N")
+                        elseif p2 < w-1 and p3 <= h-1 then
-		if string.find(string.lower(io.read()), "y") then
+                                if state=="pippette" then
-			local nsPath = string.sub(sPath, 1, #sPath-1).."a"
+                                        if p1==1 then
-			fs.move(sPath, nsPath)
+                                                if frames[sFrame][p3+sy] and frames[sFrame][p3+sy][p2+sx] then
-			sPath = nsPath
+                                                        lSel = frames[sFrame][p3+sy][p2+sx]
                                                 end
-			animated = false
+                                        elseif p1==2 then
                                                 if frames[sFrame][p3+sy] and frames[sFrame][p3+sy][p2+sx] then
                                                         rSel = frames[sFrame][p3+sy][p2+sx]
                                                 end
-	--Again this is possible, I just haven't done it. Maybe I will?
+                                        end
-	if textEnabled and (string.find(sPath, ".nfp") == #sPath-3 or string.find(sPath, ".nfa") == #sPath-3) then
+                                elseif state=="move" then
-		print("Cannot convert to nft")
+                                        updateImageLims(record)
                                         moveImage(p2,p3)
                                 elseif state=="flood" then
-	if not animated and not textEnabled and string.find(sPath, ".nfp") ~= #sPath-3 then
+                                        if p1 == 1 and lSel and frames[sFrame][p3+sy]  then
-		sPath = sPath..".nfp"
+                                                floodFill(p2,p3,frames[sFrame][p3+sy][p2+sx],lSel)
-	elseif animated and string.find(sPath, ".nfa") ~= #sPath-3 then
+                                        elseif p1 == 2 and rSel and frames[sFrame][p3+sy] then
-		sPath = sPath..".nfa"
+                                                floodFill(p2,p3,frames[sFrame][p3+sy][p2+sx],rSel)
-	elseif textEnabled and string.find(sPath, ".nft") ~= #sPath-3 then
+                                        end
-		sPath = sPath..".nft"
+                                elseif state=="corner select" then
                                         if not selectrect then
-end
+                                                selectrect = { x1=p2+sx, x2=p2+sx, y1=p3+sy, y2=p3+sy }
                                         elseif selectrect.x1 ~= p2+sx and selectrect.y1 ~= p3+sy then
-drawLogo()
+                                                if p2+sx<selectrect.x1 then selectrect.x1 = p2+sx
                                                 else selectrect.x2 = p2+sx end
 
                                                 if p3+sy<selectrect.y1 then selectrect.y1 = p3+sy
                                                 else selectrect.y2 = p3+sy end
 
                                                 state = "select"
                                         end
                                 elseif state=="textpaint" then
                                         local paintCol = lSel
                                         if p1 == 2 then paintCol = rSel end
                                         if frames[sFrame].textcol[p3+sy] then
                                                 frames[sFrame].textcol[p3+sy][p2+sx] = paintCol
                                         end
                                 elseif state=="text" then
                                         textCurX = p2 + sx
                                         textCurY = p3 + sy
                                 elseif state=="select" then
                                         if p1 == 1 then
                                                 local swidth = selectrect.x2 - selectrect.x1
                                                 local sheight = selectrect.y2 - selectrect.y1
 
                                                 selectrect.x1 = p2 + sx
                                                 selectrect.y1 = p3 + sy
                                                 selectrect.x2 = p2 + swidth + sx
                                                 selectrect.y2 = p3 + sheight + sy
                                         elseif p1 == 2 and p2 < w-2 and p3 < h-1 and boxdropAvailable then
                                                 inMenu = true
                                                 local sel = displayDropDown(p2, p3, srModes)
                                                 inMenu = false
                                                 performSelection(sel)
                                         end
                                 else
                                         local f,l = sFrame,sFrame
                                         if record then f,l = 1,framecount end
                                         local bwidth = 0
                                         if state == "brush" then bwidth = brushsize-1 end
 
                                         for i=f,l do
                                                 for x = math.max(1,p2+sx-bwidth),p2+sx+bwidth do
                                                         for y = math.max(1,p3+sy-bwidth), p3+sy+bwidth do
                                                                 if math.abs(x - (p2+sx)) + math.abs(y - (p3+sy)) <= bwidth then
                                                                         if not frames[i][y] then frames[i][y] = {} end
                                                                         if p1==1 then frames[i][y][x] = lSel
                                                                         else frames[i][y][x] = rSel end
 
                                                                         if textEnabled then
                                                                                 if not frames[i].text[y] then frames[i].text[y] = { } end
                                                                                 if not frames[i].textcol[y] then frames[i].textcol[y] = { } end
                                                                         end
                                                                 end
                                                         end
                                                 end
                                         end
                                 end
                         end
                 elseif id=="char" then
                         if state=="text" then
                                 if not frames[sFrame][textCurY] then frames[sFrame][textCurY] = { } end
                                 if not frames[sFrame].text[textCurY] then frames[sFrame].text[textCurY] = { } end
                                 if not frames[sFrame].textcol[textCurY] then frames[sFrame].textcol[textCurY] = { } end
 
                                 if rSel then frames[sFrame][textCurY][textCurX] = rSel end
                                 if lSel then
                                         frames[sFrame].text[textCurY][textCurX] = p1
                                         frames[sFrame].textcol[textCurY][textCurX] = lSel
                                 else
                                         frames[sFrame].text[textCurY][textCurX] = " "
                                         frames[sFrame].textcol[textCurY][textCurX] = rSel
                                 end
 
                                 textCurX = textCurX+1
                                 if textCurX > w + sx - 2 then sx = textCurX - w + 2 end
                         elseif tonumber(p1) then
                                 if state=="brush" and tonumber(p1) > 1 then
                                         brushsize = tonumber(p1)
                                 elseif animated and tonumber(p1) > 0 then
                                         changeFrame(tonumber(p1))
                                 end
                         end
                 elseif id=="key" then
 						--All standard interface methods are locked when the interface is hidden
 						if interfaceHidden then
 							if p1==keys.grave then
 								performSelection("show interface")
 							end
                         --Text needs special handlers (all other keyboard shortcuts are of course reserved for typing)
                         elseif state=="text" then
                                 if p1==keys.backspace and textCurX > 1 then
                                         textCurX = textCurX-1
                                         if frames[sFrame].text[textCurY] then
                                                 frames[sFrame].text[textCurY][textCurX] = nil
                                                 frames[sFrame].textcol[textCurY][textCurX] = nil
                                         end
                                         if textCurX < sx then sx = textCurX end
                                 elseif p1==keys.left and textCurX > 1 then
                                         textCurX = textCurX-1
                                         if textCurX-1 < sx then sx = textCurX-1 end
                                 elseif p1==keys.right then
                                         textCurX = textCurX+1
                                         if textCurX > w + sx - 2 then sx = textCurX - w + 2 end
                                 elseif p1==keys.up and textCurY > 1 then
                                         textCurY = textCurY-1
                                         if textCurY-1 < sy then sy = textCurY-1 end
                                 elseif p1==keys.down then
                                         textCurY = textCurY+1
                                         if textCurY > h + sy - 1 then sy = textCurY - h + 1 end
                                 end
 
                         elseif p1==keys.leftCtrl then
                                 local sel = nil
 								if mainAvailable then
 									sel = displayDropDown(1, h-1, ddModes[#ddModes])
 								else sel = performLegacySaveExit() end
                                 performSelection(sel)
                         elseif p1==keys.leftAlt then
                                 local sel = displayDropDown(1, h-1, ddModes[1])
                                 performSelection(sel)
                         elseif p1==keys.h then
                                 performSelection("help")
                         elseif p1==keys.x then
                                 performSelection("cut")
                         elseif p1==keys.c then
                                 performSelection("copy")
                         elseif p1==keys.v then
                                 performSelection("paste")
                         elseif p1==keys.z then
                                 performSelection("clear")
                         elseif p1==keys.s then
                                 performSelection("select")
                         elseif p1==keys.tab then
                                 performSelection("hide")
                         elseif p1==keys.q then
                                 performSelection("alpha to left")
                         elseif p1==keys.w then
                                 performSelection("alpha to right")
                         elseif p1==keys.f then
                                 performSelection("flood")
                         elseif p1==keys.b then
                                 performSelection("brush")
                         elseif p1==keys.m then
                                 performSelection("move")
                         elseif p1==keys.backslash and animated then
                                 performSelection("record")
                         elseif p1==keys.p then
                                 performSelection("pippette")
                         elseif p1==keys.g and animated then
                                 performSelection("go to")
 						elseif p1==keys.grave then
 								performSelection("hide interface")
                         elseif p1==keys.period and animated then
                                 changeFrame(sFrame+1)
                         elseif p1==keys.comma and animated then
                                 changeFrame(sFrame-1)
                         elseif p1==keys.r and animated then
                                 performSelection("remove")
                         elseif p1==keys.space and animated then
                                 performSelection("play")
                         elseif p1==keys.t and textEnabled then
                                 performSelection("text")
                                 sleep(0.01)
                         elseif p1==keys.y and textEnabled then
                                 performSelection("textpaint")
                         elseif p1==keys.left then
                                 if state == "move" and toplim then
                                         updateImageLims(record)
                                         if toplim and leflim then
                                                 moveImage(leflim-1,toplim)
                                         end
                                 elseif state=="select" and selectrect.x1 > 1 then
                                         selectrect.x1 = selectrect.x1-1
                                         selectrect.x2 = selectrect.x2-1
                                 elseif sx > 0 then sx=sx-1 end
                         elseif p1==keys.right then
                                 if state == "move" then
                                         updateImageLims(record)
                                         if toplim and leflim then
                                                 moveImage(leflim+1,toplim)
                                         end
                                 elseif state=="select" then
                                         selectrect.x1 = selectrect.x1+1
                                         selectrect.x2 = selectrect.x2+1
                                 else sx=sx+1 end
                         elseif p1==keys.up then
                                 if state == "move" then
                                         updateImageLims(record)
                                         if toplim and leflim then
                                                 moveImage(leflim,toplim-1)
                                         end
                                 elseif state=="select" and selectrect.y1 > 1 then
                                         selectrect.y1 = selectrect.y1-1
                                         selectrect.y2 = selectrect.y2-1
                                 elseif sy > 0 then sy=sy-1 end
                         elseif p1==keys.down then
                                 if state == "move" then
                                         updateImageLims(record)
                                         if toplim and leflim then
                                                 moveImage(leflim,toplim+1)
                                         end
                                 elseif state=="select" then
                                         selectrect.y1 = selectrect.y1+1
                                         selectrect.y2 = selectrect.y2+1
                                 else sy=sy+1 end
                         end
                 end
         end
 end
 
 --[[
                         Section: Main
 ]]--
 
 --The first thing done is deciding what features we actually have, given the screen size
 if w < 7 or h < 4 then
 	--NPaintPro simply doesn't work at certain configurations
 	shell.run("clear")
 	print("Screen too small")
 	os.pullEvent("key")
 	return
 end
 --And reduces the number of features in others.
 determineAvailableServices()
 
 --There is no b&w support for NPP.
 if not term.isColour() then
 	shell.run("clear")
 	print("NPaintPro\nBy NitrogenFingers\n\nNPaintPro can only be run on advanced "..
 	"computers. Please reinstall on an advanced computer.")
     return
 end
 
 --Taken almost directly from edit (for consistency)
 local tArgs = {...}
 
 --Command line options can appear before the file path to specify the file format
 local ca = 1
 while ca <= #tArgs do
 	if tArgs[ca] == "-a" then animated = true
 	elseif tArgs[ca] == "-t" then textEnabled = true
 	elseif tArgs[ca] == "-d" then interfaceHidden = true
 	elseif string.sub(tArgs[ca], 1, 1) == "-" then
 		print("Unrecognized option: "..tArgs[ca])
 		return
 	else break end
 	ca = ca + 1
 end
 
 --Presently, animations and text files are not supported
 if animated and textEnabled then
     print("No support for animated text files- cannot have both -a and -t")
 	return
 end
 
 --Filepaths must be added if the screen is too small
 if #tArgs < ca then
 	if not filemakerAvailable then
 		print("Usage: npaintpro [-a,-t,-d] <path>")
 		return
 	else
 		--Otherwise do the logo draw early, to determine the file.
 		drawLogo()
 		if not runFileMaker() then return end
 	end
 else
 	sPath = shell.resolve(tArgs[ca])
 end
 
 if fs.exists(sPath) then
         if fs.isDir(sPath) then
                 print("Cannot edit a directory.")
                 return
         elseif string.find(sPath, ".nfp") ~= #sPath-3 and string.find(sPath, ".nfa") ~= #sPath-3 and
                         string.find(sPath, ".nft") ~= #sPath-3 then
                 print("Can only edit .nfp, .nft and .nfa files:",string.find(sPath, ".nfp"),#sPath-3)
                 return
         end
 
         if string.find(sPath, ".nfa") == #sPath-3 then
                 animated = true
         end
 
         if string.find(sPath, ".nft") == #sPath-3 then
                 textEnabled = true
         end
 
         if string.find(sPath, ".nfp") == #sPath-3 and animated then
                 print("Convert to nfa? Y/N")
                 if string.find(string.lower(io.read()), "y") then
                         local nsPath = string.sub(sPath, 1, #sPath-1).."a"
                         fs.move(sPath, nsPath)
                         sPath = nsPath
                 else
                         animated = false
                 end
         end
 
         --Again this is possible, I just haven't done it. Maybe I will?
         if textEnabled and (string.find(sPath, ".nfp") == #sPath-3 or string.find(sPath, ".nfa") == #sPath-3) then
                 print("Cannot convert to nft")
         end
 else
         if not animated and not textEnabled and string.find(sPath, ".nfp") ~= #sPath-3 then
                 sPath = sPath..".nfp"
         elseif animated and string.find(sPath, ".nfa") ~= #sPath-3 then
                 sPath = sPath..".nfa"
         elseif textEnabled and string.find(sPath, ".nft") ~= #sPath-3 then
                 sPath = sPath..".nft"
         end
 end
 
 init()
 handleEvents()
 
 term.setBackgroundColour(colours.black)
 shell.run("clear")