LiteLoader 1.6.4_02 - experimental - added basic mod list gui and enable/disable mod functionality

Mumfrey
1 parent 3e896077
Showing 9 changed files with 1146 additions and 11 deletions
java/com/mumfrey/liteloader/core/EnabledModsList.java
java/com/mumfrey/liteloader/core/Events.java
java/com/mumfrey/liteloader/core/LiteLoader.java
java/com/mumfrey/liteloader/core/LiteLoaderBootstrap.java
java/com/mumfrey/liteloader/gui/GuiCheckbox.java
java/com/mumfrey/liteloader/gui/GuiModListEntry.java
java/com/mumfrey/liteloader/gui/GuiScreenModInfo.java
java/com/mumfrey/liteloader/gui/GuiSimpleScrollBar.java
res/assets/liteloader/textures/gui/about.png
@@ -40,6 +40,11 @@ public class EnabledModsList
 	private transient Boolean defaultEnabledValue = Boolean.TRUE;
 	private transient boolean allowSave = true;
+	/**
+	 * JSON file containing the list of enabled/disabled mods by profile
+	 */
+	private transient File enabledModsFile = null;
+	
 	private EnabledModsList()
 	{
 		// Private because we are always instanced by the static createFrom() method below
@@ -151,6 +156,7 @@ public class EnabledModsList
 			{
 				reader = new FileReader(file);
 				EnabledModsList instance = gson.fromJson(reader, EnabledModsList.class);
+				instance.setEnabledModsFile(file);
 				return instance;
 			}
 			catch (Exception ex)
@@ -171,7 +177,9 @@ public class EnabledModsList
 			}
 		}
-		return new EnabledModsList();
+		EnabledModsList instance = new EnabledModsList();
+		instance.setEnabledModsFile(file);
+		return instance;
 	}
 	/**
@@ -207,4 +215,33 @@ public class EnabledModsList
 			}
 		}
 	}
+	
+	/**
+	 * Save to the file we were loaded from
+	 */
+	public void save()
+	{
+		if (this.enabledModsFile != null)
+		{
+			this.saveTo(this.enabledModsFile);
+		}
+	}
+	
+	/**
+	 * Get whether saving this list is allowed
+	 */
+	public boolean saveAllowed()
+	{
+		return this.allowSave;
+	}
+
+	public File getEnabledModsFile()
+	{
+		return this.enabledModsFile;
+	}
+
+	public void setEnabledModsFile(File enabledModsFile)
+	{
+		this.enabledModsFile = enabledModsFile;
+	}
 }
@@ -3,6 +3,8 @@ package com.mumfrey.liteloader.core;
 import java.util.LinkedList;
 import java.util.logging.Level;
+import org.lwjgl.input.Mouse;
+
 import net.minecraft.src.*;
 import com.mumfrey.liteloader.*;
@@ -223,7 +225,6 @@ public class Events implements IPlayerUsage
 			this.pluginChannels.addPluginChannelListener((PluginChannelListener)listener);
 		}
 	}
-
 	/**
 	 * Initialise mod hooks
@@ -448,6 +449,10 @@ public class Events implements IPlayerUsage
 	 */
 	public void onRender()
 	{
+		this.currentResolution = new ScaledResolution(this.minecraft.gameSettings, this.minecraft.displayWidth, this.minecraft.displayHeight);
+		this.screenWidth = this.currentResolution.getScaledWidth();
+		this.screenHeight = this.currentResolution.getScaledHeight();
+		
 		this.loader.onRender();
 		for (RenderListener renderListener : this.renderListeners)
@@ -521,10 +526,6 @@ public class Events implements IPlayerUsage
 	 */
 	public void onRenderHUD()
 	{
-		this.currentResolution = new ScaledResolution(this.minecraft.gameSettings, this.minecraft.displayWidth, this.minecraft.displayHeight);
-		this.screenWidth = this.currentResolution.getScaledWidth();
-		this.screenHeight = this.currentResolution.getScaledHeight();
-		
 		if (!this.minecraft.gameSettings.hideGUI || this.minecraft.currentScreen != null)
 		{
 			for (HUDRenderListener hudRenderListener : this.hudRenderListeners)
@@ -583,6 +584,10 @@ public class Events implements IPlayerUsage
 		{
 			this.loader.onTick(partialTicks, inGame);
 		}
+
+		int mouseX = Mouse.getX() * this.screenWidth / this.minecraft.displayWidth;
+		int mouseY = this.screenHeight - Mouse.getY() * this.screenHeight / this.minecraft.displayHeight - 1;
+		this.loader.postRender(mouseX, mouseY, partialTicks);
 		// Iterate tickable mods
 		for (Tickable tickable : this.tickListeners)
@@ -19,9 +19,12 @@ import java.util.logging.Logger;
 import javax.activity.InvalidActivityException;
+import org.lwjgl.input.Keyboard;
+
 import net.minecraft.launchwrapper.LaunchClassLoader;
 import net.minecraft.src.CrashReport;
 import net.minecraft.src.GuiControls;
+import net.minecraft.src.GuiMainMenu;
 import net.minecraft.src.GuiScreen;
 import net.minecraft.src.KeyBinding;
 import net.minecraft.src.Minecraft;
@@ -35,6 +38,7 @@ import com.mumfrey.liteloader.*;
 import com.mumfrey.liteloader.crashreport.CallableLiteLoaderBrand;
 import com.mumfrey.liteloader.crashreport.CallableLiteLoaderMods;
 import com.mumfrey.liteloader.gui.GuiControlsPaginated;
+import com.mumfrey.liteloader.gui.GuiScreenModInfo;
 import com.mumfrey.liteloader.permissions.PermissionsManagerClient;
 import com.mumfrey.liteloader.util.PrivateFields;
@@ -196,6 +200,23 @@ public final class LiteLoader
 	private Map<KeyBinding, Integer> storedModKeyBindings = new HashMap<KeyBinding, Integer>();
 	/**
+	 * Setting which determines whether we show the "mod info" screen tab in the main menu
+	 */
+	private boolean displayModInfoScreenTab = true;
+	
+	/**
+	 * Override for the "mod info" tab setting, so that mods which want to handle the mod info themselves
+	 * can temporarily disable the function without having to change the underlying property
+	 */
+	private boolean hideModInfoScreenTab = false;
+	
+	/**
+	 * Active "mod info" screen, drawn as an overlay when in the main menu and made the active screen if
+	 * the user clicks the tab
+	 */
+	private GuiScreenModInfo modInfoScreen;
+	
+	/**
 	 * Pre-init routine, called using reflection by the tweaker
 	 * 
 	 * @param gameDirectory Game directory passed to the tweaker
@@ -295,6 +316,7 @@ public final class LiteLoader
 			this.paginateControls = this.bootstrap.getAndStoreBooleanProperty("controls.pages", true);
 			this.inhibitSoundManagerReload = this.bootstrap.getAndStoreBooleanProperty("soundManagerFix", true);
+			this.displayModInfoScreenTab = this.bootstrap.getAndStoreBooleanProperty("modInfoScreen", true);
 			this.enumerator.discoverModClasses();
 		}
@@ -328,7 +350,7 @@ public final class LiteLoader
 		this.events.initHooks();
 		this.startupComplete = true;
-		this.enabledModsList.saveTo(this.enabledModsFile);
+		this.enabledModsList.save();
 		this.bootstrap.writeProperties();
 	}
@@ -880,6 +902,33 @@ public final class LiteLoader
 			}
 		}
 	}
+	
+	/**
+	 * @param partialTicks
+	 */
+	void postRender(int mouseX, int mouseY, float partialTicks)
+	{
+		if (this.minecraft.currentScreen instanceof GuiMainMenu && this.displayModInfoScreenTab && !this.hideModInfoScreenTab)
+		{
+			// If we're at the main menu, prepare the overlay
+			if (this.modInfoScreen == null || this.modInfoScreen.getMenu() != this.minecraft.currentScreen)
+			{
+				this.modInfoScreen = new GuiScreenModInfo(this.minecraft, (GuiMainMenu)this.minecraft.currentScreen, this, this.enabledModsList);
+			}
+
+			this.modInfoScreen.drawScreen(mouseX, mouseY, partialTicks);
+		}
+		else if (this.minecraft.currentScreen != this.modInfoScreen && this.modInfoScreen != null)
+		{
+			// If we're in any other screen, kill the overlay
+			this.modInfoScreen.release();
+			this.modInfoScreen = null;
+		}
+		else if (this.minecraft.currentScreen instanceof GuiMainMenu && Keyboard.isKeyDown(Keyboard.KEY_LCONTROL) && Keyboard.isKeyDown(Keyboard.KEY_LSHIFT) && Keyboard.isKeyDown(Keyboard.KEY_TAB))
+		{
+			this.minecraft.displayGuiScreen(new GuiScreenModInfo(this.minecraft, (GuiMainMenu)this.minecraft.currentScreen, this, this.enabledModsList));
+		}			
+	}
 	/**
 	 * @param partialTicks
@@ -891,6 +940,11 @@ public final class LiteLoader
 		this.permissionsManager.onTick(this.minecraft, partialTicks, inGame);
 		this.checkAndStoreKeyBindings();
+		
+		if (this.modInfoScreen != null && this.minecraft.currentScreen != this.modInfoScreen)
+		{
+			this.modInfoScreen.updateScreen();
+		}
 	}
 	/**
@@ -963,16 +1017,40 @@ public final class LiteLoader
 		}
 		catch (IOException ex) {}
 	}
-
+	
+	/**
+	 * Set the "mod info" screen tab to hidden, regardless of the property setting
+	 */
+	public void hideModInfoScreenTab()
+	{
+		this.hideModInfoScreenTab = true;
+	}
+	
+	/**
+	 * Set whether the "mod info" screen tab should be shown in the main menu
+	 */
+	public void setDisplayModInfoScreenTab(boolean show)
+	{
+		this.displayModInfoScreenTab = show;
+		this.bootstrap.setBooleanProperty("modInfoScreen", show);
+		this.bootstrap.writeProperties();
+	}
+	
+	/**
+	 * Get whether the "mod info" screen tab is shown in the main menu
+	 */
+	public boolean getDisplayModInfoScreenTab()
+	{
+		return this.displayModInfoScreenTab;
+	}
+	
 	private static void logInfo(String string, Object... args)
 	{
-//		System.out.println("<INFO> " + String.format(string, args));
 		LiteLoader.logger.info(String.format(string, args));
 	}
 	private static void logWarning(String string, Object... args)
 	{
-//		System.out.println("<WARN> " + String.format(string, args));
 		LiteLoader.logger.warning(String.format(string, args));
 	}
@@ -40,7 +40,7 @@ class LiteLoaderBootstrap implements ILoaderBootstrap
 	/**
 	 * Liteloader version
 	 */
-	public static final LiteLoaderVersion VERSION = LiteLoaderVersion.MC_1_6_4_R1;
+	public static final LiteLoaderVersion VERSION = LiteLoaderVersion.MC_1_6_4_R2;
 	/**
 	 * Local logger reference
+package com.mumfrey.liteloader.gui;
+
+import static org.lwjgl.opengl.GL11.*;
+
+import net.minecraft.src.GuiButton;
+import net.minecraft.src.Minecraft;
+
+/**
+ * Super-simple implementation of a checkbox control
+ * 
+ * @author Adam Mummery-Smith
+ */
+public class GuiCheckbox extends GuiButton
+{
+	public boolean checked;
+	
+	public GuiCheckbox(int controlId, int xPosition, int yPosition, String displayString)
+	{
+		super(controlId, xPosition, yPosition, 200, 12, displayString);
+	}
+	
+	@Override
+	public void drawButton(Minecraft minecraft, int mouseX, int mouseY)
+	{
+		if (this.drawButton)
+		{
+			minecraft.getTextureManager().bindTexture(GuiScreenModInfo.aboutTextureResource);
+			glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+			this.field_82253_i = mouseX >= this.xPosition && mouseY >= this.yPosition && mouseX < this.xPosition + this.width && mouseY < this.yPosition + this.height;
+			
+			this.drawTexturedModalRect(this.xPosition, this.yPosition, this.checked ? 134 : 122, 80, 12, 12);
+			this.mouseDragged(minecraft, mouseX, mouseY);
+			
+			int colour = 0xE0E0E0;
+			if (!this.enabled) colour = 0xA0A0A0;
+			else if (this.field_82253_i) colour = 0xFFFFA0;
+			
+			this.drawString(minecraft.fontRenderer, this.displayString, this.xPosition + 16, this.yPosition + 2, colour);
+		}
+	}
+}
+package com.mumfrey.liteloader.gui;
+
+import com.mumfrey.liteloader.LiteMod;
+import com.mumfrey.liteloader.core.ClassPathMod;
+import com.mumfrey.liteloader.core.EnabledModsList;
+import com.mumfrey.liteloader.core.LiteLoader;
+import com.mumfrey.liteloader.core.ModFile;
+
+import net.minecraft.src.FontRenderer;
+import net.minecraft.src.Gui;
+
+/**
+ * Represents a mod in the mod info screen, keeps track of mod information and provides methods
+ * for displaying the mod in the mod list and drawing the selected mod info
+ *
+ * @author Adam Mummery-Smith
+ */
+public class GuiModListEntry extends Gui
+{
+	private static final int PANEL_HEIGHT = 32;
+	private static final int PANEL_SPACING = 4;
+	
+	/**
+	 * Enabled mods list, keep a reference so that we can toggle mod enablement when required
+	 */
+	private EnabledModsList enabledModsList;
+	
+	/**
+	 * For text display
+	 */
+	private FontRenderer fontRenderer;
+
+	/**
+	 * The metadata name (id) of the mod, used as the enablement/disablement key
+	 */
+	private String metaName;
+	
+	/**
+	 * Display name of the mod, disabled mods use the file/folder name
+	 */
+	private String name;
+	
+	/**
+	 * Mod version string
+	 */
+	private String version;
+	
+	/**
+	 * Mod author, from the metadata
+	 */
+	private String author;
+	
+	/**
+	 * Mod URL, from the metadata
+	 */
+	private String url;
+	
+	/**
+	 * Mod description, from metadata
+	 */
+	private String description;
+	
+	/**
+	 * Whether the mod is currently active
+	 */
+	private boolean enabled;
+	
+	/**
+	 * Whether the mod can be toggled, not all mods support this, eg. internal mods
+	 */
+	private boolean canBeToggled;
+	
+	/**
+	 * Whether the mod WILL be enabled on the next startup, if the mod is active and has been disabled this
+	 * will be false, and if it's currently disabled by has been toggled then it will be true 
+	 */
+	private boolean willBeEnabled;
+	
+	/**
+	 * True if the mouse was over this mod on the last render
+	 */
+	private boolean mouseOver;
+	
+	/**
+	 * Mod list entry for an ACTIVE mod
+	 * 
+	 * @param loader
+	 * @param enabledMods
+	 * @param fontRenderer
+	 * @param mod
+	 */
+	GuiModListEntry(LiteLoader loader, EnabledModsList enabledMods, FontRenderer fontRenderer, LiteMod mod)
+	{
+		this.enabledModsList = enabledMods;
+		this.fontRenderer    = fontRenderer;
+		this.metaName        = loader.getModMetaName(mod.getClass());
+		this.name            = mod.getName();
+		this.version         = mod.getVersion();
+		this.author          = loader.getModMetaData(mod.getClass(), "author", "Unknown");
+		this.url             = loader.getModMetaData(mod.getClass(), "url", null);
+		this.description     = loader.getModMetaData(mod.getClass(), "description", "");
+		this.enabled         = true;
+		this.canBeToggled    = this.metaName != null && this.enabledModsList.saveAllowed();
+		this.willBeEnabled   = true;
+	}
+	
+	/**
+	 * Mod list entry for a currently disabled mod
+	 * 
+	 * @param loader
+	 * @param enabledMods
+	 * @param fontRenderer
+	 * @param file
+	 */
+	GuiModListEntry(LiteLoader loader, EnabledModsList enabledMods, FontRenderer fontRenderer, ModFile file)
+	{
+		this.enabledModsList = enabledMods;
+		this.fontRenderer    = fontRenderer;
+		this.metaName        = file.getModName().toLowerCase();
+		this.name            = file instanceof ClassPathMod ? file.getModName() : file.getName();
+		this.version         = file.getVersion();
+		this.author          = file.getMetaValue("author", "Unknown");
+		this.url             = file.getMetaValue("url", null);
+		this.description     = file.getMetaValue("description", "");
+		this.enabled         = false;
+		this.canBeToggled    = this.enabledModsList.saveAllowed();
+		this.willBeEnabled   = enabledMods.isEnabled(loader.getProfile(), this.metaName);
+	}
+	
+	/**
+	 * Draw this list entry as a list item
+	 * 
+	 * @param mouseX
+	 * @param mouseY
+	 * @param partialTicks
+	 * @param xPosition
+	 * @param yPosition
+	 * @param width
+	 * @param selected
+	 * @return
+	 */
+	public int drawListEntry(int mouseX, int mouseY, float partialTicks, int xPosition, int yPosition, int width, boolean selected)
+	{
+		int colour1 = selected ? 0xB04785D1 : 0xB0000000;
+		drawGradientRect(xPosition, yPosition, xPosition + width, yPosition + PANEL_HEIGHT, colour1, 0xB0333333);
+		
+		this.fontRenderer.drawString(this.name, xPosition + 5, yPosition + 2, this.enabled ? 0xFFFFFFFF : 0xFF999999);
+		this.fontRenderer.drawString("Version " + this.version, xPosition + 5, yPosition + 12, 0xFF999999);
+		
+		String status = "Active";
+		
+		if (this.canBeToggled)
+		{
+			if (!this.enabled && !this.willBeEnabled) status = "\2477Disabled";
+			if (!this.enabled &&  this.willBeEnabled) status = "\247aEnabled on next startup"; 
+			if ( this.enabled && !this.willBeEnabled) status = "\247cDisabled on next startup";
+		}
+		
+		this.fontRenderer.drawString(status, xPosition + 5, yPosition + 22, 0xFF4785D1);
+		
+		this.mouseOver = mouseX > xPosition && mouseX < xPosition + width && mouseY > yPosition && mouseY < yPosition + PANEL_HEIGHT; 
+		drawRect(xPosition, yPosition, xPosition + 1, yPosition + PANEL_HEIGHT, this.mouseOver ? 0xFFFFFFFF : 0xFF999999);
+		
+		return PANEL_HEIGHT + PANEL_SPACING;
+	}
+	
+	/**
+	 * Draw this entry as the info page
+	 * 
+	 * @param mouseX
+	 * @param mouseY
+	 * @param partialTicks
+	 * @param xPosition
+	 * @param yPosition
+	 * @param width
+	 */
+	public void drawInfo(int mouseX, int mouseY, float partialTicks, int xPosition, int yPosition, int width)
+	{
+		yPosition += 2;
+
+		this.fontRenderer.drawString(this.name, xPosition + 5, yPosition, 0xFFFFFFFF); yPosition += 10;
+		this.fontRenderer.drawString("Version " + this.version, xPosition + 5, yPosition, 0xFF999999); yPosition += 10;
+
+		drawRect(xPosition + 5, yPosition, xPosition + width, yPosition + 1, 0xFF999999); yPosition += 4;
+
+		this.fontRenderer.drawString("Authors: \2477" + this.author, xPosition + 5, yPosition, 0xFFFFFFFF); yPosition += 10;
+		if (this.url != null)
+		{
+			this.fontRenderer.drawString(this.url, xPosition + 5, yPosition, 0xB04785D1); yPosition += 10;
+		}
+
+		drawRect(xPosition + 5, yPosition, xPosition + width, yPosition + 1, 0xFF999999); yPosition += 4;
+		
+		this.fontRenderer.drawSplitString(this.description, xPosition + 5, yPosition, width - 5, 0xFFFFFFFF);
+	}
+
+	/**
+	 * Toggle the enablement status of this mod, if supported
+	 */
+	public void toggleEnabled()
+	{
+		if (this.canBeToggled)
+		{
+			this.willBeEnabled = !this.willBeEnabled;
+			this.enabledModsList.setEnabled(LiteLoader.getProfile(), this.metaName, this.willBeEnabled);
+			this.enabledModsList.save();
+		}
+	}
+	
+	public String getKey()
+	{
+		return this.metaName + Integer.toHexString(this.hashCode());
+	}
+	
+	public String getName()
+	{
+		return this.name;
+	}
+
+	public String getVersion()
+	{
+		return this.version;
+	}
+
+	public String getAuthor()
+	{
+		return this.author;
+	}
+
+	public String getDescription()
+	{
+		return this.description;
+	}
+
+	public boolean isEnabled()
+	{
+		return this.enabled;
+	}
+
+	public boolean canBeToggled()
+	{
+		return this.canBeToggled;
+	}
+
+	public boolean willBeEnabled()
+	{
+		return this.willBeEnabled;
+	}
+	
+	public boolean mouseWasOver()
+	{
+		return this.mouseOver;
+	}
+}
+package com.mumfrey.liteloader.gui;
+
+import static org.lwjgl.opengl.GL11.*;
+
+import java.awt.image.BufferedImage;
+import java.nio.DoubleBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+import javax.imageio.ImageIO;
+
+import org.lwjgl.BufferUtils;
+import org.lwjgl.input.Keyboard;
+import org.lwjgl.input.Mouse;
+
+import com.mumfrey.liteloader.LiteMod;
+import com.mumfrey.liteloader.core.EnabledModsList;
+import com.mumfrey.liteloader.core.LiteLoader;
+import com.mumfrey.liteloader.core.ModFile;
+
+import net.minecraft.src.DynamicTexture;
+import net.minecraft.src.GuiButton;
+import net.minecraft.src.GuiMainMenu;
+import net.minecraft.src.GuiScreen;
+import net.minecraft.src.Minecraft;
+import net.minecraft.src.ResourceLocation;
+import net.minecraft.src.Tessellator;
+
+/**
+ * GUI screen which displays info about loaded mods and also allows them to be enabled and
+ * disabled. An instance of this class is created every time the main menu is displayed and is
+ * drawn as an overlay until the tab is clicked, at which point it becomes the active GUI screen
+ * and draws the parent main menu screen as its background to give the appearance of being
+ * overlaid on the main menu. 
+ *
+ * @author Adam Mummery-Smith
+ */
+public class GuiScreenModInfo extends GuiScreen
+{
+	private static final int LEFT_EDGE  = 80;
+	private static final int TAB_WIDTH  = 20;
+	private static final int TAB_HEIGHT = 40;
+	private static final int TAB_TOP    = 20;
+
+	/**
+	 * Used for clipping
+	 */
+	private static DoubleBuffer doubleBuffer = BufferUtils.createByteBuffer(64).asDoubleBuffer();
+	
+	public static ResourceLocation aboutTextureResource;
+	private static DynamicTexture aboutTexture;
+
+	private GuiMainMenu mainMenu;
+	
+	private long tickNumber;
+	
+	private double lastTick;
+	
+	private double tweenAmount = 0.0, tweenRate = 0.08;
+	
+	private boolean mouseDown, toggled;
+	
+	private float tabOpacity = 0.0F;
+	
+	private List<GuiModListEntry> mods = new ArrayList<GuiModListEntry>();
+	
+	private GuiModListEntry selectedMod = null;
+	
+	private String activeModText = "0 mod(s) loaded";
+	
+	private int listHeight;
+	
+	private GuiSimpleScrollBar scrollBar = new GuiSimpleScrollBar();
+	
+	private GuiButton btnToggle;
+	
+	private GuiCheckbox chkEnabled;
+	
+	public GuiScreenModInfo(Minecraft minecraft, GuiMainMenu mainMenu, LiteLoader loader, EnabledModsList enabledModsList)
+	{
+		this.mc = minecraft;
+		this.mainMenu = mainMenu;
+		
+		if (aboutTexture == null)
+		{
+			try
+			{
+				BufferedImage aboutImage = ImageIO.read(GuiScreenModInfo.class.getResourceAsStream("/assets/liteloader/textures/gui/about.png"));
+				aboutTexture = new DynamicTexture(aboutImage);
+				aboutTextureResource = minecraft.getTextureManager().getDynamicTextureLocation("about_assets", aboutTexture);
+			}
+			catch (Exception ex) {}
+		}
+		
+		this.enumerateMods(loader, enabledModsList);
+	}
+	
+	/**
+	 * Populate the mods list
+	 * 
+	 * @param loader
+	 * @param enabledModsList
+	 */
+	private void enumerateMods(LiteLoader loader, EnabledModsList enabledModsList)
+	{
+		this.activeModText = String.format("%d mod(s) loaded", loader.getLoadedMods().size());
+		
+		Map<String, GuiModListEntry> sortedMods = new TreeMap<String, GuiModListEntry>();
+		
+		for (LiteMod mod : loader.getLoadedMods())
+		{
+			GuiModListEntry modListEntry = new GuiModListEntry(loader, enabledModsList, this.mc.fontRenderer, mod);
+			sortedMods.put(modListEntry.getKey(), modListEntry);
+		}
+		
+		for (ModFile disabledMod : loader.getDisabledMods())
+		{
+			GuiModListEntry modListEntry = new GuiModListEntry(loader, enabledModsList, this.mc.fontRenderer, disabledMod);
+			sortedMods.put(modListEntry.getKey(), modListEntry);
+		}
+		
+		this.mods.addAll(sortedMods.values());
+		
+		if (this.mods.size() > 0)
+		{
+			this.selectedMod = this.mods.get(0);
+		}
+	}
+
+	/**
+	 * Release references prior to being disposed
+	 */
+	public void release()
+	{
+		this.mainMenu = null;
+	}
+
+	/**
+	 * Get the parent menu
+	 */
+	public GuiMainMenu getMenu()
+	{
+		return this.mainMenu;
+	}
+	
+	/* (non-Javadoc)
+	 * @see net.minecraft.src.GuiScreen#initGui()
+	 */
+	@SuppressWarnings("unchecked")
+	@Override
+	public void initGui()
+	{
+		int left = LEFT_EDGE + 16 + (this.width - LEFT_EDGE - 28) / 2;
+		
+		this.buttonList.clear();
+		this.buttonList.add(this.btnToggle = new GuiButton(0, left, this.height - 50, 100, 20, "Enable mod"));
+		this.buttonList.add(this.chkEnabled = new GuiCheckbox(1, LEFT_EDGE + 12, this.height - 17, "Show LiteLoader tab on main menu"));
+		
+		this.selectMod(this.selectedMod);
+	}
+	
+	/* (non-Javadoc)
+	 * @see net.minecraft.src.GuiScreen#setWorldAndResolution(net.minecraft.src.Minecraft, int, int)
+	 */
+	@Override
+	public void setWorldAndResolution(Minecraft minecraft, int width, int height)
+	{
+		if (this.mc.currentScreen == this)
+		{
+			// Set res in parent screen if we are the active GUI
+			this.mainMenu.setWorldAndResolution(minecraft, width, height);
+		}
+		
+		super.setWorldAndResolution(minecraft, width, height);
+	}
+	
+	/* (non-Javadoc)
+	 * @see net.minecraft.src.GuiScreen#updateScreen()
+	 */
+	@Override
+	public void updateScreen()
+	{
+		this.tickNumber++;
+		
+		if (this.mc.currentScreen == this)
+		{
+			this.mainMenu.updateScreen();
+			this.chkEnabled.checked = LiteLoader.getInstance().getDisplayModInfoScreenTab();
+		}
+		
+		if (this.toggled)
+		{
+			this.onToggled();
+		}
+	}
+	
+	/* (non-Javadoc)
+	 * @see net.minecraft.src.GuiScreen#drawScreen(int, int, float)
+	 */
+	@Override
+	public void drawScreen(int mouseX, int mouseY, float partialTicks)
+	{
+		boolean active = this.mc.currentScreen == this;
+		
+		this.width = this.mainMenu.width;
+		this.height = this.mainMenu.height;
+
+		if (active)
+		{
+			glClear(GL_DEPTH_BUFFER_BIT);
+			this.mainMenu.drawScreen(-10, -10, partialTicks);
+			glClear(GL_DEPTH_BUFFER_BIT);
+		}
+		
+		float xOffset = (this.width - LEFT_EDGE) * this.calcTween(partialTicks, active) + 16.0F + (this.tabOpacity * -32.0F);
+		mouseX -= (int)xOffset;
+		
+		boolean mouseOverTab = mouseX > LEFT_EDGE - TAB_WIDTH && mouseX < LEFT_EDGE && mouseY > TAB_TOP && mouseY < TAB_TOP + TAB_HEIGHT;
+		this.handleMouseClick(mouseX, mouseY, partialTicks, active, mouseOverTab);
+		
+		this.tabOpacity = mouseOverTab || this.tweenAmount > 0.0 ? 0.5F : Math.max(0.0F, this.tabOpacity - partialTicks * 0.1F);
+		this.drawPanel(mouseX, mouseY, partialTicks, active, xOffset);
+	}
+
+	/**
+	 * @param mouseX
+	 * @param mouseY
+	 * @param partialTicks
+	 * @param active
+	 * @param xOffset
+	 */
+	private void drawPanel(int mouseX, int mouseY, float partialTicks, boolean active, float xOffset)
+	{
+		glPushMatrix();
+		glTranslatef(xOffset, 0.0F, 0.0F);
+		
+		drawRect(LEFT_EDGE, 0, this.width, this.height, 0xB0000000);
+		drawRect(LEFT_EDGE, 0, LEFT_EDGE + 1, TAB_TOP, 0xFFFFFFFF);
+		drawRect(LEFT_EDGE, TAB_TOP + TAB_HEIGHT, LEFT_EDGE + 1, this.height, 0xFFFFFFFF);
+		
+		this.mc.getTextureManager().bindTexture(aboutTextureResource);
+		glDrawTexturedRect(LEFT_EDGE - TAB_WIDTH, TAB_TOP, TAB_WIDTH + 1, TAB_HEIGHT, 80, 80, 122, 160, 0.5F + this.tabOpacity);
+
+		if (this.tweenAmount > 0.0)
+		{
+			glDrawTexturedRect(LEFT_EDGE + 12, 12, 128, 40, 0, 0, 256, 80, 1.0F);
+			glDrawTexturedRect(this.width - 32 - 12, 12, 32, 45, 0, 80, 64, 170, 1.0F);
+			
+			this.fontRenderer.drawString("Version " + LiteLoader.getVersion(), LEFT_EDGE + 12 + 38, 50, 0xFFFFFFFF);
+			this.fontRenderer.drawString(this.activeModText, LEFT_EDGE + 12 + 38, 60, 0xFFAAAAAA);
+
+			drawRect(LEFT_EDGE + 12, 80, this.width - 12, 81, 0xFF999999);
+			drawRect(LEFT_EDGE + 12, this.height - 24, this.width - 12, this.height - 23, 0xFF999999);
+			
+			int panelTop = 83;
+			int innerWidth = this.width - LEFT_EDGE - 24 - 4;
+			int listWidth = innerWidth / 2;
+
+			this.drawModsList(mouseX, mouseY, partialTicks, panelTop, listWidth);
+			this.drawSelectedMod(mouseX, mouseY, partialTicks, panelTop, listWidth);
+
+			super.drawScreen(mouseX, mouseY, partialTicks);
+		}
+		
+		glPopMatrix();
+	}
+
+	/**
+	 * @param mouseX
+	 * @param mouseY
+	 * @param partialTicks
+	 * @param panelWidth
+	 */
+	public void drawModsList(int mouseX, int mouseY, float partialTicks, int panelTop, int panelWidth)
+	{
+		int panelHeight = this.height - 26 - panelTop;
+		this.scrollBar.drawScrollBar(mouseX, mouseY, partialTicks, LEFT_EDGE + 12 + panelWidth - 5, panelTop, 5, panelHeight, this.listHeight);
+
+		glEnableClipping(LEFT_EDGE + 12, LEFT_EDGE + 12 + panelWidth - 6, panelTop, this.height - 26);
+		
+		glPushMatrix();
+		glTranslatef(0.0F, panelTop - this.scrollBar.getValue(), 0.0F);
+		
+		mouseY -= (panelTop - this.scrollBar.getValue());
+		
+		int yPos = 0;
+		for (GuiModListEntry mod : this.mods)
+		{
+			yPos += mod.drawListEntry(mouseX, mouseY, partialTicks, LEFT_EDGE + 12, yPos, panelWidth - 6, mod == this.selectedMod);
+		}
+		
+		glPopMatrix();
+		glDisableClipping();
+		
+		this.listHeight = yPos;
+		this.scrollBar.setMaxValue(this.listHeight - panelHeight);
+	}
+
+	/**
+	 * @param mouseX
+	 * @param mouseY
+	 * @param partialTicks
+	 * @param panelTop
+	 * @param listWidth
+	 */
+	public void drawSelectedMod(int mouseX, int mouseY, float partialTicks, int panelTop, int listWidth)
+	{
+		if (this.selectedMod != null)
+		{
+			int left = LEFT_EDGE + 12 + listWidth;
+			int right = this.width - 12;
+
+			glEnableClipping(left, right, panelTop, this.height - 54);
+			this.selectedMod.drawInfo(mouseX, mouseY, partialTicks, left, panelTop, right - left);
+			glDisableClipping();
+		}
+	}
+
+	/**
+	 * @param mod
+	 * @return
+	 */
+	public void selectMod(GuiModListEntry mod)
+	{
+		this.selectedMod = mod;
+		this.btnToggle.drawButton = false;
+		
+		if (this.selectedMod != null && this.selectedMod.canBeToggled())
+		{
+			this.btnToggle.drawButton = true;
+			this.btnToggle.displayString = this.selectedMod.willBeEnabled() ? "Disable mod" : "Enable mod";
+		}
+	}
+	
+	/* (non-Javadoc)
+	 * @see net.minecraft.src.GuiScreen#actionPerformed(net.minecraft.src.GuiButton)
+	 */
+	@Override
+	protected void actionPerformed(GuiButton button)
+	{
+		if (button.id == 0 && this.selectedMod != null)
+		{
+			this.selectedMod.toggleEnabled();
+			this.selectMod(this.selectedMod);
+		}
+		
+		if (button.id == 1)
+		{
+			this.chkEnabled.checked = !this.chkEnabled.checked;
+			LiteLoader.getInstance().setDisplayModInfoScreenTab(this.chkEnabled.checked);
+			
+			if (!this.chkEnabled.checked)
+			{
+				this.chkEnabled.displayString = "Show LiteLoader tab on main menu \247e(use \2479CTRL\247e+\2479SHIFT\247e+\2479TAB\247e)";
+			}
+		}
+	}
+	
+	/* (non-Javadoc)
+	 * @see net.minecraft.src.GuiScreen#keyTyped(char, int)
+	 */
+	@Override
+	protected void keyTyped(char keyChar, int keyCode)
+	{
+		if (keyCode == Keyboard.KEY_ESCAPE)
+		{
+			this.onToggled();
+			return;
+		}
+	}
+	
+	/* (non-Javadoc)
+	 * @see net.minecraft.src.GuiScreen#mouseClicked(int, int, int)
+	 */
+	@Override
+	protected void mouseClicked(int mouseX, int mouseY, int button)
+	{
+		if (button == 0)
+		{
+			if (this.scrollBar.wasMouseOver())
+			{
+				this.scrollBar.setDragging(true);
+			}
+			
+			if (mouseY > 83 && mouseY < this.height - 26)
+			{
+				for (GuiModListEntry mod : this.mods)
+				{
+					if (mod.mouseWasOver()) this.selectMod(mod); 
+				}
+			}
+		}
+		
+		super.mouseClicked(mouseX, mouseY, button);
+	}
+	
+	/* (non-Javadoc)
+	 * @see net.minecraft.src.GuiScreen#mouseMovedOrUp(int, int, int)
+	 */
+	@Override
+	protected void mouseMovedOrUp(int mouseX, int mouseY, int button)
+	{
+		if (button == 0)
+		{
+			this.scrollBar.setDragging(false);
+		}
+		
+		super.mouseMovedOrUp(mouseX, mouseY, button);
+	}
+	
+	/* (non-Javadoc)
+	 * @see net.minecraft.src.GuiScreen#handleMouseInput()
+	 */
+	@Override
+	public void handleMouseInput()
+	{
+		int mouseWheelDelta = Mouse.getEventDWheel();
+		
+		if (mouseWheelDelta != 0)
+		{
+			this.scrollBar.offsetValue(-mouseWheelDelta / 8);
+		}
+		
+		super.handleMouseInput();
+	}
+
+	/**
+	 * @param mouseX
+	 * @param active
+	 * @param mouseOverTab
+	 */
+	public void handleMouseClick(int mouseX, int mouseY, float partialTicks, boolean active, boolean mouseOverTab)
+	{
+		boolean mouseDown = Mouse.isButtonDown(0);
+		if (((active && mouseX < LEFT_EDGE) || mouseOverTab) && !this.mouseDown && mouseDown)
+		{
+			this.mouseDown = true;
+			this.toggled = true;
+		}
+		else if (this.mouseDown && !mouseDown)
+		{
+			this.mouseDown = false;
+		}
+	}
+
+	/**
+	 * @param partialTicks
+	 * @param active
+	 * @return
+	 */
+	private float calcTween(float partialTicks, boolean active)
+	{
+		double tickValue = this.tickNumber + partialTicks;
+		
+		if (active && this.tweenAmount < 1.0)
+		{
+			this.tweenAmount = Math.min(1.0, this.tweenAmount + ((tickValue - this.lastTick) * this.tweenRate));
+		}
+		else if (!active && this.tweenAmount > 0.0)
+		{
+			this.tweenAmount = Math.max(0.0, this.tweenAmount - ((tickValue - this.lastTick) * this.tweenRate));
+		}
+		
+		this.lastTick = tickValue;
+		return 1.0F - (float)Math.sin(this.tweenAmount * 0.5 * Math.PI);
+	}
+
+	/**
+	 * Called when the tab is clicked
+	 */
+	private void onToggled()
+	{
+		this.toggled = false;
+		this.mc.displayGuiScreen(this.mc.currentScreen == this ? this.mainMenu : this);
+	}
+	
+	/**
+	 * @param x
+	 * @param y
+	 * @param width
+	 * @param height
+	 * @param u
+	 * @param v
+	 * @param u2
+	 * @param v2
+	 * @param alpha
+	 */
+	private static void glDrawTexturedRect(int x, int y, int width, int height, int u, int v, int u2, int v2, float alpha)
+	{
+		glDisable(GL_LIGHTING);
+		glEnable(GL_BLEND);
+		glAlphaFunc(GL_GREATER, 0.0F);
+		glEnable(GL_TEXTURE_2D);
+		glColor4f(1.0F, 1.0F, 1.0F, alpha);
+		
+		float texMapScale = 0.00390625F; // 256px
+		
+		Tessellator tessellator = Tessellator.instance;
+		tessellator.startDrawingQuads();
+		tessellator.addVertexWithUV(x + 0,     y + height, 0, u  * texMapScale, v2 * texMapScale);
+		tessellator.addVertexWithUV(x + width, y + height, 0, u2 * texMapScale, v2 * texMapScale);
+		tessellator.addVertexWithUV(x + width, y + 0,      0, u2 * texMapScale, v  * texMapScale);
+		tessellator.addVertexWithUV(x + 0,     y + 0,      0, u  * texMapScale, v  * texMapScale);
+		tessellator.draw();
+		
+		glDisable(GL_BLEND);
+		glAlphaFunc(GL_GREATER, 0.01F);
+	}
+	
+	/**
+	 * Enable OpenGL clipping planes (uses planes 2, 3, 4 and 5)
+	 * 
+	 * @param xLeft Left edge clip or -1 to not use this plane
+	 * @param xRight Right edge clip or -1 to not use this plane
+	 * @param yTop Top edge clip or -1 to not use this plane
+	 * @param yBottom Bottom edge clip or -1 to not use this plane
+	 */
+	private final static void glEnableClipping(int xLeft, int xRight, int yTop, int yBottom)
+	{
+		// Apply left edge clipping if specified
+		if (xLeft != -1)
+		{
+			doubleBuffer.clear();
+			doubleBuffer.put(1).put(0).put(0).put(-xLeft).flip();
+			glClipPlane(GL_CLIP_PLANE2, doubleBuffer);
+			glEnable(GL_CLIP_PLANE2);
+		}
+		
+		// Apply right edge clipping if specified
+		if (xRight != -1)
+		{
+			doubleBuffer.clear();
+			doubleBuffer.put(-1).put(0).put(0).put(xRight).flip();
+			glClipPlane(GL_CLIP_PLANE3, doubleBuffer);
+			glEnable(GL_CLIP_PLANE3);
+		}
+		
+		// Apply top edge clipping if specified
+		if (yTop != -1)
+		{
+			doubleBuffer.clear();
+			doubleBuffer.put(0).put(1).put(0).put(-yTop).flip();
+			glClipPlane(GL_CLIP_PLANE4, doubleBuffer);
+			glEnable(GL_CLIP_PLANE4);
+		}
+		
+		// Apply bottom edge clipping if specified
+		if (yBottom != -1)
+		{
+			doubleBuffer.clear();
+			doubleBuffer.put(0).put(-1).put(0).put(yBottom).flip();
+			glClipPlane(GL_CLIP_PLANE5, doubleBuffer);
+			glEnable(GL_CLIP_PLANE5);
+		}
+	}
+	
+	/**
+	 * Disable OpenGL clipping planes (uses planes 2, 3, 4 and 5)
+	 */
+	private final static void glDisableClipping()
+	{
+		glDisable(GL_CLIP_PLANE5);
+		glDisable(GL_CLIP_PLANE4);
+		glDisable(GL_CLIP_PLANE3);
+		glDisable(GL_CLIP_PLANE2);
+	}
+}
 \ No newline at end of file
+package com.mumfrey.liteloader.gui;
+
+import net.minecraft.src.Gui;
+
+/**
+ * Extremely simple scrollbar implementation
+ *
+ * @author Adam Mummery-Smith
+ */
+public class GuiSimpleScrollBar extends Gui
+{
+	/**
+	 * Current value 
+	 */
+	private int value = 0;
+	
+	/**
+	 * Current maximum value
+	 */
+	private int maxValue = 100;
+	
+	private int backColour = 0x44FFFFFF;
+	private int foreColour = 0xFFFFFFFF;
+	
+	/**
+	 * True if mouse was over the drag bar when last drawn 
+	 */
+	private boolean mouseOver = false;
+	
+	/**
+	 * True if currently dragging the scroll bar
+	 */
+	private boolean dragging = false;
+	
+	/**
+	 * Value prior to starting to drag
+	 */
+	private int mouseDownValue = 0;
+	
+	/**
+	 * mouse Y coordinate prior to starting to drag
+	 */
+	private int mouseDownY = 0;
+
+	/**
+	 * Get the current scroll value
+	 */
+	public int getValue()
+	{
+		return this.value;
+	}
+
+	/**
+	 * Set the scroll value, the value is clamped between 0 and the current max value
+	 */
+	public void setValue(int value)
+	{
+		this.value = Math.min(Math.max(value, 0), this.maxValue);
+	}
+	
+	/**
+	 * Offset the scroll value by the specified amount, the value is clamped between 0 and the current max value
+	 */
+	public void offsetValue(int offset)
+	{
+		this.setValue(this.value + offset);
+	}
+
+	/**
+	 * Get the current max value
+	 */
+	public int getMaxValue()
+	{
+		return this.maxValue;
+	}
+
+	/**
+	 * Sets the current max value
+	 */
+	public void setMaxValue(int maxValue)
+	{
+		this.maxValue = Math.max(0, maxValue);
+		this.value = Math.min(this.value, this.maxValue);
+	}
+	
+	/**
+	 * Returns true if the mouse was over the drag bar on the last render
+	 */
+	public boolean wasMouseOver()
+	{
+		return this.mouseOver;
+	}
+	
+	/**
+	 * Set the current dragging state
+	 */
+	public void setDragging(boolean dragging)
+	{
+		this.dragging = dragging;
+	}
+	
+	/**
+	 * Draw the scroll bar
+	 * 
+	 * @param mouseX
+	 * @param mouseY
+	 * @param partialTicks
+	 * @param xPosition
+	 * @param yPosition
+	 * @param width
+	 * @param height
+	 * @param totalHeight
+	 */
+	public void drawScrollBar(int mouseX, int mouseY, float partialTicks, int xPosition, int yPosition, int width, int height, int totalHeight)
+	{
+		drawRect(xPosition, yPosition, xPosition + width, yPosition + height, this.backColour);
+
+		if (totalHeight > 0)
+		{
+			int slideHeight = height - 2;
+			float pct = Math.min(1.0F, (float)slideHeight / (float)totalHeight);
+			int barHeight = (int)(pct * slideHeight);
+			int barTravel = slideHeight - barHeight;
+			int barPosition = this.maxValue > 0 ? yPosition + 1 + (int)((this.value / (float)this.maxValue) * barTravel) : 0;
+			
+			drawRect(xPosition + 1, barPosition, xPosition + width - 1, barPosition + barHeight, this.foreColour);
+			
+			this.mouseOver = mouseX > xPosition && mouseX < xPosition + width && mouseY > barPosition && mouseY < barPosition + barHeight;
+			this.handleDrag(mouseY, barTravel);
+		}
+	}
+
+	/**
+	 * @param mouseY
+	 * @param barTravel
+	 */
+	public void handleDrag(int mouseY, int barTravel)
+	{
+		if (this.dragging)
+		{
+			// Convert pixel delta to value delta
+			float valuePerPixel = (float)this.maxValue / barTravel;
+			this.setValue((int)(this.mouseDownValue + ((mouseY - this.mouseDownY) * valuePerPixel)));
+		}
+		else
+		{
+			this.mouseDownY = mouseY;
+			this.mouseDownValue = this.value;
+		}
+	}
+}