home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / sun / awt / Win32GraphicsDevice.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  7.6 KB  |  371 lines
  1. package sun.awt;
  2.  
  3. import java.awt.AWTPermission;
  4. import java.awt.DisplayMode;
  5. import java.awt.Frame;
  6. import java.awt.GraphicsConfiguration;
  7. import java.awt.GraphicsDevice;
  8. import java.awt.GraphicsEnvironment;
  9. import java.awt.Rectangle;
  10. import java.awt.Window;
  11. import java.awt.image.ColorModel;
  12. import java.awt.peer.WindowPeer;
  13. import java.security.AccessController;
  14. import java.util.ArrayList;
  15. import java.util.Vector;
  16. import sun.awt.windows.WWindowPeer;
  17. import sun.java2d.d3d.D3DContext;
  18. import sun.java2d.opengl.WGLGraphicsConfig;
  19. import sun.java2d.windows.WindowsFlags;
  20. import sun.security.action.GetPropertyAction;
  21.  
  22. public class Win32GraphicsDevice extends GraphicsDevice implements DisplayChangedListener {
  23.    int screen;
  24.    ColorModel dynamicColorModel;
  25.    ColorModel colorModel;
  26.    GraphicsConfiguration[] configs;
  27.    GraphicsConfiguration defaultConfig;
  28.    boolean offscreenAccelerationEnabled = true;
  29.    private D3DContext d3dContext;
  30.    private SunDisplayChanger topLevels = new SunDisplayChanger();
  31.    private static boolean pfDisabled;
  32.    private static AWTPermission fullScreenExclusivePermission;
  33.    private Rectangle ownerWindowedModeBounds = null;
  34.    private DisplayMode defaultDisplayMode;
  35.  
  36.    private static native void initIDs();
  37.  
  38.    public boolean isOffscreenAccelerationEnabled() {
  39.       return this.offscreenAccelerationEnabled;
  40.    }
  41.  
  42.    native void initDevice(int var1);
  43.  
  44.    public Win32GraphicsDevice(int var1) {
  45.       this.screen = var1;
  46.       this.initDevice(var1);
  47.    }
  48.  
  49.    public int getType() {
  50.       return 0;
  51.    }
  52.  
  53.    public int getScreen() {
  54.       return this.screen;
  55.    }
  56.  
  57.    public String getIDstring() {
  58.       return "\\Display" + this.screen;
  59.    }
  60.  
  61.    public GraphicsConfiguration[] getConfigurations() {
  62.       if (this.configs == null) {
  63.          if (WindowsFlags.isOGLEnabled() && this.isDefaultDevice()) {
  64.             this.defaultConfig = this.getDefaultConfiguration();
  65.             if (this.defaultConfig != null) {
  66.                this.configs = new GraphicsConfiguration[1];
  67.                this.configs[0] = this.defaultConfig;
  68.                return this.configs;
  69.             }
  70.          }
  71.  
  72.          int var1 = this.getMaxConfigs(this.screen);
  73.          int var2 = this.getDefaultPixID(this.screen);
  74.          Vector var3 = new Vector(var1);
  75.          if (var2 == 0) {
  76.             this.defaultConfig = Win32GraphicsConfig.getConfig(this, var2);
  77.             var3.addElement(this.defaultConfig);
  78.          } else {
  79.             for(int var4 = 1; var4 <= var1; ++var4) {
  80.                if (this.isPixFmtSupported(var4, this.screen)) {
  81.                   if (var4 == var2) {
  82.                      this.defaultConfig = Win32GraphicsConfig.getConfig(this, var4);
  83.                      var3.addElement(this.defaultConfig);
  84.                   } else {
  85.                      var3.addElement(Win32GraphicsConfig.getConfig(this, var4));
  86.                   }
  87.                }
  88.             }
  89.          }
  90.  
  91.          this.configs = new GraphicsConfiguration[var3.size()];
  92.          var3.copyInto(this.configs);
  93.       }
  94.  
  95.       return this.configs;
  96.    }
  97.  
  98.    protected int getMaxConfigs(int var1) {
  99.       return pfDisabled ? 1 : this.getMaxConfigsImpl(var1);
  100.    }
  101.  
  102.    private native int getMaxConfigsImpl(int var1);
  103.  
  104.    protected native boolean isPixFmtSupported(int var1, int var2);
  105.  
  106.    protected int getDefaultPixID(int var1) {
  107.       return pfDisabled ? 0 : this.getDefaultPixIDImpl(var1);
  108.    }
  109.  
  110.    private native int getDefaultPixIDImpl(int var1);
  111.  
  112.    public GraphicsConfiguration getDefaultConfiguration() {
  113.       if (this.defaultConfig == null) {
  114.          if (WindowsFlags.isOGLEnabled() && this.isDefaultDevice()) {
  115.             int var1 = WGLGraphicsConfig.getDefaultPixFmt(this.screen);
  116.             this.defaultConfig = WGLGraphicsConfig.getConfig(this, var1);
  117.             if (WindowsFlags.isOGLVerbose()) {
  118.                if (this.defaultConfig != null) {
  119.                   System.out.print("OpenGL pipeline enabled");
  120.                } else {
  121.                   System.out.print("Could not enable OpenGL pipeline");
  122.                }
  123.  
  124.                System.out.println(" for default config on screen " + this.screen);
  125.             }
  126.          }
  127.  
  128.          if (this.defaultConfig == null) {
  129.             this.defaultConfig = Win32GraphicsConfig.getConfig(this, 0);
  130.          }
  131.       }
  132.  
  133.       return this.defaultConfig;
  134.    }
  135.  
  136.    public String toString() {
  137.       return "Win32GraphicsDevice[screen=" + this.screen + "]";
  138.    }
  139.  
  140.    private boolean isDefaultDevice() {
  141.       return this == GraphicsEnvironment.getLocalGraphicsEnvironment().getDefaultScreenDevice();
  142.    }
  143.  
  144.    private native boolean isDDEnabledOnDeviceNative(int var1);
  145.  
  146.    public D3DContext getD3DContext() {
  147.       if (this.d3dContext == null) {
  148.          this.d3dContext = new D3DContext(this);
  149.       }
  150.  
  151.       return this.d3dContext;
  152.    }
  153.  
  154.    public boolean isDDEnabledOnDevice() {
  155.       return WindowsFlags.isDDEnabled() && this.isDDEnabledOnDeviceNative(this.screen);
  156.    }
  157.  
  158.    public boolean isD3DEnabledOnDevice() {
  159.       return WindowsFlags.isD3DEnabled() && (WindowsFlags.isD3DSet() || this.getFullScreenWindow() != null) && (this.getD3DContext().getDeviceCaps() & 16384) != 0;
  160.    }
  161.  
  162.    private static boolean isFSExclusiveModeAllowed() {
  163.       SecurityManager var0 = System.getSecurityManager();
  164.       if (var0 != null) {
  165.          if (fullScreenExclusivePermission == null) {
  166.             fullScreenExclusivePermission = new AWTPermission("fullScreenExclusive");
  167.          }
  168.  
  169.          try {
  170.             var0.checkPermission(fullScreenExclusivePermission);
  171.          } catch (SecurityException var2) {
  172.             return false;
  173.          }
  174.       }
  175.  
  176.       return true;
  177.    }
  178.  
  179.    public boolean isFullScreenSupported() {
  180.       return isFSExclusiveModeAllowed();
  181.    }
  182.  
  183.    private Frame getToplevelOwner(Window var1) {
  184.       Window var2 = var1;
  185.  
  186.       while(var2 != null) {
  187.          var2 = var2.getOwner();
  188.          if (var2 instanceof Frame) {
  189.             return (Frame)var2;
  190.          }
  191.       }
  192.  
  193.       return null;
  194.    }
  195.  
  196.    public synchronized void setFullScreenWindow(Window var1) {
  197.       Window var2 = this.getFullScreenWindow();
  198.       if (var1 != var2) {
  199.          if (!this.isFullScreenSupported()) {
  200.             super.setFullScreenWindow(var1);
  201.          } else {
  202.             if (var2 != null) {
  203.                if (this.defaultDisplayMode != null) {
  204.                   this.setDisplayMode(this.defaultDisplayMode);
  205.                   this.defaultDisplayMode = null;
  206.                }
  207.  
  208.                WWindowPeer var3 = (WWindowPeer)var2.getPeer();
  209.                if (var3 != null) {
  210.                   synchronized(var3) {
  211.                      var3.destroyBuffers();
  212.                      this.exitFullScreenExclusive(this.isDDEnabledOnDevice(), this.screen, var3);
  213.                   }
  214.                }
  215.  
  216.                if (!(var2 instanceof Frame)) {
  217.                   Frame var4 = this.getToplevelOwner(var2);
  218.                   if (var4 != null && this.ownerWindowedModeBounds != null) {
  219.                      var4.setBounds(this.ownerWindowedModeBounds);
  220.                   }
  221.  
  222.                   this.ownerWindowedModeBounds = null;
  223.                }
  224.             }
  225.  
  226.             super.setFullScreenWindow(var1);
  227.             if (var1 != null) {
  228.                this.defaultDisplayMode = this.getDisplayMode();
  229.                if (!(var1 instanceof Frame)) {
  230.                   Frame var9 = this.getToplevelOwner(var1);
  231.                   if (var9 != null) {
  232.                      this.ownerWindowedModeBounds = var9.getBounds();
  233.                      var9.setBounds(var1.getBounds());
  234.                   }
  235.                }
  236.  
  237.                WWindowPeer var10 = (WWindowPeer)var1.getPeer();
  238.                synchronized(var10) {
  239.                   this.enterFullScreenExclusive(this.isDDEnabledOnDevice(), this.screen, var10);
  240.                }
  241.  
  242.                var10.updateGC();
  243.                var10.resetTargetGC();
  244.             }
  245.  
  246.          }
  247.       }
  248.    }
  249.  
  250.    private native void enterFullScreenExclusive(boolean var1, int var2, WindowPeer var3);
  251.  
  252.    private native void exitFullScreenExclusive(boolean var1, int var2, WindowPeer var3);
  253.  
  254.    public boolean isDisplayChangeSupported() {
  255.       return this.isFullScreenSupported() && this.getFullScreenWindow() != null;
  256.    }
  257.  
  258.    public synchronized void setDisplayMode(DisplayMode var1) {
  259.       if (!this.isDisplayChangeSupported()) {
  260.          super.setDisplayMode(var1);
  261.       } else if (var1 != null && (var1 = this.getMatchingDisplayMode(var1)) != null) {
  262.          if (!this.getDisplayMode().equals(var1)) {
  263.             Window var2 = this.getFullScreenWindow();
  264.             if (var2 != null) {
  265.                WWindowPeer var3 = (WWindowPeer)var2.getPeer();
  266.                this.configDisplayMode(this.screen, var3, var1.getWidth(), var1.getHeight(), var1.getBitDepth(), var1.getRefreshRate());
  267.                Rectangle var4 = this.getDefaultConfiguration().getBounds();
  268.                var2.setBounds(var4.x, var4.y, var1.getWidth(), var1.getHeight());
  269.             } else {
  270.                throw new IllegalStateException("Must be in fullscreen mode in order to set display mode");
  271.             }
  272.          }
  273.       } else {
  274.          throw new IllegalArgumentException("Invalid display mode");
  275.       }
  276.    }
  277.  
  278.    private native DisplayMode getCurrentDisplayMode(int var1);
  279.  
  280.    private native void configDisplayMode(int var1, WindowPeer var2, int var3, int var4, int var5, int var6);
  281.  
  282.    private native void enumDisplayModes(int var1, ArrayList var2);
  283.  
  284.    private native boolean isDisplayModeAvailable(int var1, int var2, int var3, int var4, int var5);
  285.  
  286.    public synchronized DisplayMode getDisplayMode() {
  287.       DisplayMode var1 = this.getCurrentDisplayMode(this.screen);
  288.       return var1;
  289.    }
  290.  
  291.    public synchronized DisplayMode[] getDisplayModes() {
  292.       ArrayList var1 = new ArrayList();
  293.       this.enumDisplayModes(this.screen, var1);
  294.       int var2 = var1.size();
  295.       DisplayMode[] var3 = new DisplayMode[var2];
  296.  
  297.       for(int var4 = 0; var4 < var2; ++var4) {
  298.          var3[var4] = (DisplayMode)var1.get(var4);
  299.       }
  300.  
  301.       return var3;
  302.    }
  303.  
  304.    private synchronized DisplayMode getMatchingDisplayMode(DisplayMode var1) {
  305.       if (!this.isDisplayChangeSupported()) {
  306.          return null;
  307.       } else if (this.isDDEnabledOnDevice()) {
  308.          return this.isDisplayModeAvailable(this.screen, var1.getWidth(), var1.getHeight(), var1.getBitDepth(), var1.getRefreshRate()) ? var1 : null;
  309.       } else {
  310.          DisplayMode[] var2 = this.getDisplayModes();
  311.  
  312.          for(DisplayMode var6 : var2) {
  313.             if (var1.equals(var6) || var1.getRefreshRate() == 0 && var1.getWidth() == var6.getWidth() && var1.getHeight() == var6.getHeight() && var1.getBitDepth() == var6.getBitDepth()) {
  314.                return var6;
  315.             }
  316.          }
  317.  
  318.          return null;
  319.       }
  320.    }
  321.  
  322.    public void displayChanged() {
  323.       this.d3dContext = null;
  324.       this.dynamicColorModel = null;
  325.       this.defaultConfig = null;
  326.       this.configs = null;
  327.       this.topLevels.notifyListeners();
  328.    }
  329.  
  330.    public void paletteChanged() {
  331.    }
  332.  
  333.    public void addDisplayChangedListener(DisplayChangedListener var1) {
  334.       this.topLevels.add(var1);
  335.    }
  336.  
  337.    public void removeDisplayChangedListener(DisplayChangedListener var1) {
  338.       this.topLevels.remove(var1);
  339.    }
  340.  
  341.    private native ColorModel makeColorModel(int var1, boolean var2);
  342.  
  343.    public ColorModel getDynamicColorModel() {
  344.       if (this.dynamicColorModel == null) {
  345.          this.dynamicColorModel = this.makeColorModel(this.screen, true);
  346.       }
  347.  
  348.       return this.dynamicColorModel;
  349.    }
  350.  
  351.    public ColorModel getColorModel() {
  352.       if (this.colorModel == null) {
  353.          this.colorModel = this.makeColorModel(this.screen, false);
  354.       }
  355.  
  356.       return this.colorModel;
  357.    }
  358.  
  359.    private native int getDeviceMemoryNative(int var1);
  360.  
  361.    public int getAvailableAcceleratedMemory() {
  362.       return this.getDefaultConfiguration() instanceof WGLGraphicsConfig ? super.getAvailableAcceleratedMemory() : this.getDeviceMemoryNative(this.screen);
  363.    }
  364.  
  365.    static {
  366.       String var0 = (String)AccessController.doPrivileged(new GetPropertyAction("sun.awt.nopixfmt"));
  367.       pfDisabled = var0 != null;
  368.       initIDs();
  369.    }
  370. }
  371.