private void init() {
      // run through some based OpenGL capability settings. Textures
      // enabled, back face culling enabled, depth texting is on,
      GL11.glEnable(GL11.GL_TEXTURE_2D);
      GL11.glEnable(GL11.GL_CULL_FACE);
      // Enable hidden-surface removal
      GL11.glEnable(GL11.GL_DEPTH_TEST);
      GL11.glDepthFunc(GL11.GL_LEQUAL);
      GL11.glShadeModel(GL11.GL_SMOOTH); 
      
      // Set the clear color to Black
      GL11.glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
      // Set the depth to clear at
      GL11.glClearDepth(1.0f);
      
      // define the properties for the perspective of the scene
      GL11.glMatrixMode(GL11.GL_PROJECTION);
      GL11.glLoadIdentity();      
      GLU.gluPerspective(45.0f, ((float) 800) / ((float) 600), 0.1f, 100.0f);
      GL11.glMatrixMode(GL11.GL_MODELVIEW);
      // Enable really nice perspective calculations
      GL11.glHint(GL11.GL_PERSPECTIVE_CORRECTION_HINT, GL11.GL_NICEST);
      // Enable line antialiasing
      GL11.glHint(GL11.GL_LINE_SMOOTH_HINT, GL11.GL_NICEST);
}

GL11.glColor3f(1.0f, 1.0f, 1.0f);

GL11.glEnable(GL11.GL_BLEND);
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);

GL11.glDisable(GL11.GL_BLEND);

package common.gui.font;

import common.gui.texture.*;

import java.awt.Color;
import java.awt.Font;
import java.awt.image.BufferedImage;
import java.awt.Graphics2D;
import java.awt.FontMetrics;

import java.awt.geom.AffineTransform;
import java.awt.image.AffineTransformOp;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import java.nio.ByteOrder;

import org.lwjgl.opengl.GL11;

public class BitmapFont {

   private static final BitmapFont source = new BitmapFont();
   
   private static final Color OPAQUE_WHITE = new Color(0xFFFFFFFF, true);
   private static final Color TRANSPARENT_BLACK = new Color(0x00000000, true);
   
   /** The display list id, where each character to print to the screen
    *  is added to this value.  For example, listBase+65 would be the character
    *  'A'.*/
   private int listBase;
   /** The texture for this font */
   private Texture texture;
   /** The current font */
   private String currentFont = "Courier New";
   
   
   private BitmapFont() {
      init();
   }
   
   private void init() {
      buildFont();
      buildDisplayLists();
   }
   
   private void buildFont() {
      try {
         texture = TextureMgr.get().getTexture("res/Font.bmp");
      } catch (Exception e) {
         e.printStackTrace();
         System.exit(0);
      }
   }
   
   private int testid;
   /**
    * Create the display lists used for drawing characters to the screen.
    */
   private void buildDisplayLists() {
      listBase = GL11.glGenLists(256); // Storage For 256 Characters
      testid = GL11.glGenLists(1);
      
      
      float x = (float)(texture.getWidth()/2);
      float y = (float)(texture.getHeight()/2);
      x = 2.0f;
      y = 2.0f;
      GL11.glNewList(testid, GL11.GL_COMPILE);
      texture.bind();
      GL11.glBegin(GL11.GL_QUADS);
         GL11.glTexCoord2f(1.0f, 0.0f);
         GL11.glVertex3f(x, -y, 0.0f);
         GL11.glTexCoord2f(1.0f, 1.0f);
         GL11.glVertex3f(x, y, 0.0f);
         GL11.glTexCoord2f(0.0f, 1.0f);
         GL11.glVertex3f(-x, y, 0.0f);
         GL11.glTexCoord2f(0.0f, 0.0f);
         GL11.glVertex3f(-x, -y, 0.0f);
      GL11.glEnd();
      GL11.glEndList();

        /* Generate the display lists.  One for each character in the standard/extended ASCII chart.
         */
        float textureDelta = 1.0f / 16.0f;
        for(int i=0;i<256;i++) {
            float u = ((float)(i % 16)) / 16.0f;
            float v = 1.f - (((float)(i / 16)) / 16.0f);
            GL11.glNewList(listBase + i, GL11.GL_COMPILE);
            texture.bind();
            GL11.glBegin(GL11.GL_QUADS);
                GL11.glTexCoord2f(u, v - textureDelta);
                GL11.glVertex3f(-0.0450f, -0.0450f, 0.0f);
                GL11.glTexCoord2f((u + textureDelta), v - textureDelta);
                GL11.glVertex3f(0.0450f, -0.0450f, 0.0f);
                GL11.glTexCoord2f((u + textureDelta), v);
                GL11.glVertex3f(0.0450f, 0.0450f, 0.0f);
                GL11.glTexCoord2f(u, v);
                GL11.glVertex3f(-0.0450f, 0.0450f, 0.0f);
            GL11.glEnd();
            GL11.glEndList();
        }
   }
   
   public static BitmapFont get() {
      return source;
   }
   
   /**
    * Prepare OpenGL for Orthographic rendering.  The method will ensure that
    * all states are saved.
    */
   private void enterOrtho() {
      GL11.glDisable(GL11.GL_DEPTH_TEST);
      
      // Load the projection mode and save it's current state
      GL11.glMatrixMode(GL11.GL_PROJECTION); 
      GL11.glPushMatrix();
      GL11.glLoadIdentity();
      
      // Set up orthographic projection mode
      GL11.glOrtho(0, 800, 0, 600, -1, 1);
      
      // Enter model view mode
      GL11.glMatrixMode(GL11.GL_MODELVIEW);
      GL11.glPushMatrix();
      GL11.glLoadIdentity();
   }
   
   /**
    * Leave Orthographic rendering in OpenGL.  Will restore all states saved
    * by enterOrtho().
    */
   private void leaveOrtho() {
      // Restore the state of the projection mode
      GL11.glMatrixMode(GL11.GL_PROJECTION);
      GL11.glPopMatrix();
      
      // Restore the state of the model view mode
      GL11.glMatrixMode(GL11.GL_MODELVIEW);
      GL11.glPopMatrix();
      GL11.glEnable(GL11.GL_DEPTH_TEST);
   }
   
   public void print(String msg, float x, float y) {
      enterOrtho();
      GL11.glTranslatef(x, y, 0.0f);
      
      // Ignore null value
      if (msg != null) {
         texture.bind();
         // Print the characters
         for(int i = 0; i < msg.length(); i++) {
            GL11.glCallList(listBase + msg.charAt(i));
            GL11.glTranslatef(1.0f, 0.0f, 0.0f);
            }         
      }
      leaveOrtho();   
   }
   
}

package CarringtonPlace.Help;
import CarringtonPlace.IView.IBEIView;
import CarringtonPlace.Model.HelpBook;
import CarringtonPlace.Model.Constants;

import javax.swing.JEditorPane;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JSplitPane;
import javax.swing.UIManager;

import javax.swing.JTree;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.TreeSelectionModel;
import javax.swing.event.TreeSelectionEvent;
import javax.swing.event.TreeSelectionListener;

import java.io.File;

import java.net.URL;
import java.io.IOException;
import java.awt.Dimension;
import java.awt.GridLayout;


/**
 * <p>Title: </p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2004</p>
 * <p>Company: </p>
 * @author not attributable
 * @version 1.0
 */

public class HelpHTMLPane extends JEditorPane implements IBEIView
{  private HelpBook model;

   private URL helpURL;

   public HelpHTMLPane(HelpBook theModel) 
   {  super();
      this.model = theModel;
      
      this.initializeHelp();
      
      
      this.model.addView(this);
   }
   
   private void initializeHelp() 
   {  //String s = "http://www.icebreakersentertainment.com";
      //String s = "file://" + Constants.HELP_PATH + "test.html";
      //String s = "test.html";
      String s = "file://C:/test.html";
      //System.out.println(s);
      
      try
      {  this.helpURL = new URL(s);
      } catch (Exception e)
      {  System.err.println("Could not parse URL address.");
      }
      
      //this.helpURL = HelpHTMLPane.class.getResource("Main.html");
      if (helpURL == null) 
      {  System.err.println("Couldn't open help file: " + s);
      } else 
      {  System.out.println("Help URL is " + this.helpURL);
      }
      
      this.displayURL(helpURL);
   }
   
   private void displayURL(URL url) 
   {  try 
      {  if (url != null) 
         {  this.setPage(url);
         } else 
         {  //null url
            this.setText("File Not Found");
            System.out.println("Attempted to display a null URL.");
         }
      } catch (IOException e) 
      {  System.err.println("Attempted to read a bad URL: " + url);
      }
   }

   
   public void updateView()
   {
   }
   
   public void updateColors()
   {
   }

}

package View;
import Model.World;


import java.awt.Canvas;
import java.awt.Color;
import java.awt.GraphicsEnvironment;
import java.awt.GraphicsDevice;
import java.awt.DisplayMode;
import java.awt.Frame;
import javax.swing.JFrame;
/**
 * <p>Title: </p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2004</p>
 * <p>Company: </p>
 * @author not attributable
 * @version 1.0
 */

public class GameFrame extends Frame
{  private GameCanvas gameCanvas;
   private MainMenuCanvas mainMenuCanvas;
   private MenuCanvas menuCanvas;

   private World model;

   private GraphicsEnvironment ge;
   private GraphicsDevice gd;

   private int lengthX = 800;
   private int lengthY = 600;

   private DisplayMode originalDisplayMode;

   private boolean fullScreen;

   public GameFrame(World theModel)
   {  this.model = theModel;
      this.model.addView(this);

      this.ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
      this.gd = this.ge.getDefaultScreenDevice();

      this.fullScreen = this.gd.isFullScreenSupported();
      this.setUndecorated(this.fullScreen);
      this.setResizable(!this.fullScreen);
      this.setIgnoreRepaint(this.fullScreen);
      this.initializeFullScreen();

      this.gameCanvas = new GameCanvas(this.lengthX, this.lengthY);
      this.add(this.gameCanvas);
      this.gameCanvas.setVisible(true);

   }

   private void initializeFullScreen()
   {  if (this.fullScreen)
      {  this.originalDisplayMode = this.gd.getDisplayMode();

         try
         {  this.gd.setFullScreenWindow(this);
            DisplayMode newMode = new DisplayMode(this.lengthX, this.lengthY, 24, 60);
            this.gd.setDisplayMode(newMode);
         }  catch (Exception e)
         {  if (this.gd.isDisplayChangeSupported())
            {  if (!this.originalDisplayMode.equals(this.gd.getDisplayMode()))
               {  this.gd.setDisplayMode(this.originalDisplayMode);
               }

               this.gd.setFullScreenWindow(null);
            }
         }
      }

      this.setBackground(Color.black);
      this.pack();
      //this.setVisible(true);
   }

   public void updateView()
   {  this.gameCanvas.updateView();
   }
}

package View;
import Model.World;


import java.awt.Canvas;
import java.awt.BufferCapabilities;
import java.awt.image.*;
import java.awt.Graphics;
import java.awt.Color;
import java.awt.Graphics2D;

/**
 * <p>Title: </p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2004</p>
 * <p>Company: </p>
 * @author not attributable
 * @version 1.0
 */

public class GameCanvas extends Canvas
{  private BufferStrategy bufferStrategy;
   private int numBuffers = 2;

   private int lengthX;
   private int lengthY;


   public GameCanvas(int lengthX, int lengthY)
   {  super();
      this.lengthX = lengthX;
      this.lengthY = lengthY;

      this.setSize(this.lengthX, this.lengthY);

      this.registerListeners();

      this.setIgnoreRepaint(true);
      this.setBackground(Color.white);
   }

   public void registerListeners()
   {
   }

   /* Ready the buffers for drawing onto the canvas - Should only be needed to be
      called from within the canvas itself
   */
   public void initializeGraphics()
   {

      this.createBufferStrategy(this.numBuffers);
      this.bufferStrategy = this.getBufferStrategy();
   }

   /* Set the canvas visible/invisible, but also initialize the canvas BufferStrategy if
      the canvas is to be shown in the GameFrame
   */
   public void setVisible(boolean state)
   {  if (state)
      {  this.initializeGraphics();
      }
      super.setVisible(state);
   }

   /* This method will 'try' to get the BufferStrategys' graphics, draw on the canvas,
      and then display the canvas (using Page Flipping)
   */
   private void drawGraphics()
   {
      try
      {  Graphics2D g2 =  (Graphics2D) this.bufferStrategy.getDrawGraphics();
         this.render(g2);
         this.bufferStrategy.show();
         g2.dispose();
      }  catch (Exception e)
      {  System.out.println("ERROR DRAWING GRAPHICS: " + e.toString());
      }

   }

   /* This will draw (render) the graphics onto the graphics buffer supplied from
      BufferStrategy
   */
   private void render(Graphics2D g2)
   {  if (!this.bufferStrategy.contentsLost())
      {  System.out.println("Rendering graphics");
         g2.setColor(Color.green);
         g2.fillRect(0, 0, this.lengthX, this.lengthY);
         g2.setColor(Color.white);
         g2.drawString("Testing 1, 2, 3.  GameCanvas TEST.", 10, 10);
         g2.setColor(Color.magenta);
         g2.fillRect(40, 100, 80, 250);
      } else
      {  System.out.println("Contents of the buffer have been lost...Cannot render Canvas.");
      }
   }

   public void updateView()
   {  this.drawGraphics();
   }


}

//initialize the graphics when i create the canvas
public void initializeGraphics()
   {

      this.createBufferStrategy(this.numBuffers);
      this.bufferStrategy = this.getBufferStrategy();
   }

//draw the graphics on the canvas...called from a render loop
private void drawGraphics()
   {  
      try
      {  Graphics2D g2 =  (Graphics2D) this.bufferStrategy.getDrawGraphics();
         this.render(g2);
         this.bufferStrategy.show();
         g2.dispose();
      }  catch (Exception e)
      {  System.out.println("ERROR DRAWING GRAPHICS: " + e.toString());
      } 

   }

this.createBufferStrategy(this.numBuffers)

this.numBuffers = 2

this.numBuffers = 1

public class WorldView extends Canvas
{  private BufferStrategy strat

   public WorldView()
   {  super();

          this.layoutView();
          this.registerListeners();

          this.createBufferStrategy(2);
          this.strat = this.getBufferStrategy();
   }
}

private void drawGraphics()  {  
      if (!this.buffersSet)
      {  this.createBufferStrategy(2);
         this.strategy = this.getBufferStrategy();
         this.buffersSet = true;
      }
      Graphics g = this.strategy.getDrawGraphics();
      this.render(g);
      g.dispose();
      this.strategy.show();
}