gov/nasa/worldwind/awt/WorldWindowGLCanvas.java

   1 /*
   2 Copyright (C) 2001, 2006 United States Government
   3 as represented by the Administrator of the
   4 National Aeronautics and Space Administration.
   5 All Rights Reserved.
   6 */
   7 package gov.nasa.worldwind.awt;
   8
   9 import gov.nasa.worldwind.*;
  10
  11 import javax.media.opengl.*;
  12 import java.awt.*;
  13
  14 /**
  15  * <code>WorldWindowGLCanvas</code> is an AWT component for displaying World Wind {@link Model}s (globe and layers).
  16  * This implementation is a heavyweight AWT component. It derives from {@link GLCanvas} and therefore also provides a
  17  * general {@link GLDrawable} for OpenGL rendering.
  18  *
  19  * @author Tom Gaskins
  20  * @version $Id: WorldWindowGLCanvas.java 1793 2007-05-08 21:28:57Z tgaskins $
  21  */
  22 public class WorldWindowGLCanvas extends GLCanvas implements WorldWindow
  23 {
  24     private static final GLCapabilities caps = new GLCapabilities();
  25
  26     static
  27     {
  28         caps.setAlphaBits(8);
  29         caps.setRedBits(8);
  30         caps.setGreenBits(8);
  31         caps.setBlueBits(8);
  32 //        caps.setStencilBits(8);
  33         caps.setDepthBits(24);
  34     }
  35
  36     private final WorldWindowGLAutoDrawable wwd; // everything delegates to wwd
  37     private InputHandler inputHandler;
  38
  39     /**
  40      * Constructs a new <code>WorldWindowGLCanvas</code> window on the default graphics device.
  41      */
  42     public WorldWindowGLCanvas()
  43     {
  44         super(caps);
  45         try
  46         {
  47             this.wwd = new WorldWindowGLAutoDrawable(this); // TODO: Make class configurable
  48             this.createView();
  49             this.createDefaultInputHandler();
  50         }
  51         catch (Exception e)
  52         {
  53             String message = WorldWind.retrieveErrMsg("awt.WorldWindowGLSurface.UnabletoCreateWindow");
  54             WorldWind.logger().log(java.util.logging.Level.FINE, message);
  55             throw new WWRuntimeException(message, e);
  56         }
  57     }
  58
  59     /**
  60      * Constructs a new <code>WorldWindowGLCanvas</code> window on the default graphics device that will share graphics
  61      * resources with another <code>WorldWindowGLCanvas</code> window. The other window, <code>sharewith</code>, may not
  62      * be null
  63      *
  64      * @param shareWith a <code>WorldWindowGLCanvas</code> with which to share graphics resources.
  65      * @throws NullPointerException if shareWith is null
  66      * @see GLCanvas#GLCanvas(GLCapabilities,GLCapabilitiesChooser,GLContext,GraphicsDevice)
  67      */
  68     public WorldWindowGLCanvas(WorldWindowGLCanvas shareWith)
  69     {
  70         super(caps, null, shareWith.getContext(), null);
  71         try
  72         {
  73             this.wwd = new WorldWindowGLAutoDrawable(this);
  74             this.createView();
  75             this.createDefaultInputHandler();
  76         }
  77         catch (Exception e)
  78         {
  79             String message = WorldWind.retrieveErrMsg("awt.WorldWindowGLSurface.UnabletoCreateWindow");
  80             WorldWind.logger().log(java.util.logging.Level.FINE, message);
  81             throw new WWRuntimeException(message, e);
  82         }
  83     }
  84
  85     /**
  86      * Constructs a new <code>WorldWindowGLCanvas</code> window that will share graphics resources with another
  87      * <code>WorldWindowGLCanvas</code> window. The new window is created on the specified graphics device. Neither
  88      * <code> shareWith</code> or <code>device</code> may be null.
  89      *
  90      * @param shareWith a <code>WorldWindowGLCanvas</code> with which to share graphics resources.
  91      * @param device    the <code>GraphicsDevice</code> on which to create the window.
  92      * @throws NullPointerException     if <code>shareWith</code> is null
  93      * @throws IllegalArgumentException if <code>deevice</code> is null
  94      * @see GLCanvas#GLCanvas(GLCapabilities,GLCapabilitiesChooser,GLContext,GraphicsDevice)
  95      */
  96     public WorldWindowGLCanvas(WorldWindowGLCanvas shareWith, java.awt.GraphicsDevice device)
  97     {
  98         super(caps, null, shareWith.getContext(), device);
  99
 100         if (device == null)
 101         {
 102             String msg = WorldWind.retrieveErrMsg("nullValue.DeviceIsNull");
 103             WorldWind.logger().log(java.util.logging.Level.FINE, msg);
 104             throw new IllegalArgumentException(msg);
 105         }
 106         try
 107         {
 108             this.wwd = new WorldWindowGLAutoDrawable(this);
 109             this.createView();
 110             this.createDefaultInputHandler();
 111         }
 112         catch (Exception e)
 113         {
 114             String message = WorldWind.retrieveErrMsg("awt.WorldWindowGLSurface.UnabletoCreateWindow");
 115             WorldWind.logger().log(java.util.logging.Level.FINE, message);
 116             throw new WWRuntimeException(message, e);
 117         }
 118     }
 119
 120     private void createView()
 121     {
 122         this.setView((View) WorldWind.createConfigurationComponent(
 123             gov.nasa.worldwind.AVKey.VIEW_CLASS_NAME));
 124     }
 125
 126     private void createDefaultInputHandler()
 127     {
 128 //        this.inputHandler = new gov.nasa.worldwind.awt.AWTInputHandler();
 129         this.inputHandler = (InputHandler) WorldWind.createConfigurationComponent(AVKey.INPUT_HANDLER_CLASS_NAME);
 130         this.inputHandler.setEventSource(this);
 131     }
 132
 133     public InputHandler getInputHandler()
 134     {
 135         return inputHandler;
 136     }
 137
 138     public void setInputHandler(InputHandler eventSource)
 139     {
 140         if (this.inputHandler != null)
 141             this.inputHandler.setEventSource(null); // remove this window as a source of events
 142
 143         this.inputHandler = eventSource;
 144         if (this.inputHandler != null)
 145             this.inputHandler.setEventSource(this);
 146     }
 147
 148     public SceneController getSceneController()
 149     {
 150         return this.wwd.getSceneController();
 151     }
 152
 153     public PickedObjectList pick(java.awt.Point pickPoint)
 154     {
 155         return this.wwd.pick(pickPoint);
 156     }
 157
 158     public void setModel(Model model)
 159     {
 160         // null models are permissible
 161         this.wwd.setModel(model);
 162     }
 163
 164     public Model getModel()
 165     {
 166         return this.wwd.getModel();
 167     }
 168
 169     public void setView(View view)
 170     {
 171         // null views are permissible
 172         if (view != null)
 173             this.wwd.setView(view);
 174     }
 175
 176     public View getView()
 177     {
 178         return this.wwd.getView();
 179     }
 180
 181     public void setModelAndView(Model model, View view)
 182     {   // null models/views are permissible
 183         this.setModel(model);
 184         this.setView(view);
 185     }
 186
 187     public void addRenderingListener(RenderingListener listener)
 188     {
 189         this.wwd.addRenderingListener(listener);
 190     }
 191
 192     public void removeRenderingListener(RenderingListener listener)
 193     {
 194         this.wwd.removeRenderingListener(listener);
 195     }
 196
 197     public void addSelectListener(SelectListener listener)
 198     {
 199         this.inputHandler.addSelectListener(listener);
 200     }
 201
 202     public void removeSelectListener(SelectListener listener)
 203     {
 204         this.inputHandler.removeSelectListener(listener);
 205     }
 206
 207     public void addPositionListener(PositionListener listener)
 208     {
 209         this.inputHandler.addPositionListener(listener);
 210     }
 211
 212     public void removePositionListener(PositionListener listener)
 213     {
 214         this.inputHandler.removePositionListener(listener);
 215     }
 216 }