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/Win32GraphicsConfig.class

Java Class File | 2006-11-29 | 6.8 KB | 230 lines

package sun.awt;

import java.awt.AWTException;
import java.awt.BufferCapabilities;
import java.awt.Component;
import java.awt.Graphics;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.Image;
import java.awt.ImageCapabilities;
import java.awt.Rectangle;
import java.awt.Window;
import java.awt.BufferCapabilities.FlipContents;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.DirectColorModel;
import java.awt.image.ImageObserver;
import java.awt.image.VolatileImage;
import java.awt.image.WritableRaster;
import java.util.Hashtable;
import sun.awt.image.OffScreenImage;
import sun.awt.windows.WComponentPeer;
import sun.java2d.InvalidPipeException;
import sun.java2d.SurfaceData;
import sun.java2d.loops.CompositeType;
import sun.java2d.loops.RenderLoops;
import sun.java2d.loops.SurfaceType;
import sun.java2d.windows.Win32SurfaceData;
import sun.java2d.windows.WinBackBuffer;
import sun.java2d.windows.WindowsFlags;

public class Win32GraphicsConfig extends GraphicsConfiguration implements DisplayChangedListener {
   protected Win32GraphicsDevice screen;
   protected int visual;
   protected RenderLoops solidloops;
   private static BufferCapabilities bufferCaps;
   private static ImageCapabilities imageCaps;
   private SurfaceType sTypeOrig = null;
   private static final int DCM_4444_RED_MASK = 3840;
   private static final int DCM_4444_GRN_MASK = 240;
   private static final int DCM_4444_BLU_MASK = 15;
   private static final int DCM_4444_ALP_MASK = 61440;
   static ColorModel translucentCM;

   private static native void initIDs();

   public static Win32GraphicsConfig getConfig(Win32GraphicsDevice var0, int var1) {
      return new Win32GraphicsConfig(var0, var1);
   }

   /** @deprecated */
   @Deprecated
   public Win32GraphicsConfig(GraphicsDevice var1, int var2) {
      this.screen = (Win32GraphicsDevice)var1;
      this.visual = var2;
      ((Win32GraphicsDevice)var1).addDisplayChangedListener(this);
   }

   public GraphicsDevice getDevice() {
      return this.screen;
   }

   public int getVisual() {
      return this.visual;
   }

   public synchronized RenderLoops getSolidLoops(SurfaceType var1) {
      if (this.solidloops == null || this.sTypeOrig != var1) {
         this.solidloops = SurfaceData.makeRenderLoops(SurfaceType.OpaqueColor, CompositeType.SrcNoEa, var1);
         this.sTypeOrig = var1;
      }

      return this.solidloops;
   }

   public BufferedImage createCompatibleImage(int var1, int var2) {
      ColorModel var3 = this.getColorModel();
      WritableRaster var4 = var3.createCompatibleWritableRaster(var1, var2);
      return new BufferedImage(var3, var4, var3.isAlphaPremultiplied(), (Hashtable)null);
   }

   public synchronized ColorModel getColorModel() {
      return this.screen.getColorModel();
   }

   public ColorModel getDeviceColorModel() {
      return this.screen.getDynamicColorModel();
   }

   public ColorModel getColorModel(int var1) {
      switch (var1) {
         case 1:
            return this.getColorModel();
         case 2:
            return new DirectColorModel(25, 16711680, 65280, 255, 16777216);
         case 3:
            return getTranslucentColorModel();
         default:
            return null;
      }
   }

   public static ColorModel getTranslucentColorModel() {
      if (WindowsFlags.getD3DTexBpp() == 16) {
         if (translucentCM == null) {
            translucentCM = new DirectColorModel(16, 3840, 240, 15, 61440);
         }

         return translucentCM;
      } else {
         return ColorModel.getRGBdefault();
      }
   }

   public AffineTransform getDefaultTransform() {
      return new AffineTransform();
   }

   public AffineTransform getNormalizingTransform() {
      Win32GraphicsEnvironment var1 = (Win32GraphicsEnvironment)GraphicsEnvironment.getLocalGraphicsEnvironment();
      double var2 = (double)var1.getXResolution() / (double)72.0F;
      double var4 = (double)var1.getYResolution() / (double)72.0F;
      return new AffineTransform(var2, (double)0.0F, (double)0.0F, var4, (double)0.0F, (double)0.0F);
   }

   public String toString() {
      return super.toString() + "[dev=" + this.screen + ",pixfmt=" + this.visual + "]";
   }

   private native Rectangle getBounds(int var1);

   public Rectangle getBounds() {
      return this.getBounds(this.screen.getScreen());
   }

   public BufferCapabilities getBufferCapabilities() {
      if (bufferCaps == null) {
         if (WindowsFlags.isDDEnabled()) {
            bufferCaps = new DDrawBufferCapabilities(this.getImageCapabilities());
         } else {
            bufferCaps = super.getBufferCapabilities();
         }
      }

      return bufferCaps;
   }

   public ImageCapabilities getImageCapabilities() {
      if (imageCaps == null) {
         if (WindowsFlags.isDDEnabled()) {
            imageCaps = new DDrawImageCapabilities();
         } else {
            imageCaps = super.getImageCapabilities();
         }
      }

      return imageCaps;
   }

   public synchronized void displayChanged() {
      this.solidloops = null;
   }

   public void paletteChanged() {
   }

   public SurfaceData createSurfaceData(WComponentPeer var1, int var2) {
      return Win32SurfaceData.createData(var1, var2);
   }

   public Image createAcceleratedImage(Component var1, int var2, int var3) {
      ColorModel var4 = this.getColorModel(1);
      WritableRaster var5 = var4.createCompatibleWritableRaster(var2, var3);
      return new OffScreenImage(var1, var4, var5, var4.isAlphaPremultiplied());
   }

   private boolean isFullScreenExclusive(Component var1) {
      Win32GraphicsDevice var2;
      for(var2 = (Win32GraphicsDevice)this.getDevice(); var1 != null && !(var1 instanceof Window); var1 = ((Component)var1).getParent()) {
      }

      return var1 == var2.getFullScreenWindow() && var2.isDDEnabledOnDevice();
   }

   public void assertOperationSupported(Component var1, int var2, BufferCapabilities var3) throws AWTException {
      if (!this.isFullScreenExclusive(var1)) {
         throw new AWTException("The operation requested is only supported on a full-screen exclusive window");
      }
   }

   public VolatileImage createBackBuffer(WComponentPeer var1) {
      return new WinBackBuffer((Component)var1.getTarget(), (Win32SurfaceData)var1.getSurfaceData());
   }

   public void flip(WComponentPeer var1, Component var2, VolatileImage var3, BufferCapabilities.FlipContents var4) {
      int var5 = var2.getWidth();
      int var6 = var2.getHeight();
      if (var4 == FlipContents.COPIED) {
         Graphics var11 = var2.getGraphics();
         var11.drawImage(var3, 0, 0, var5, var6, (ImageObserver)null);
         var11.dispose();
      } else {
         Win32SurfaceData var7 = (Win32SurfaceData)var1.getSurfaceData();

         try {
            var7.flip(((WinBackBuffer)var3).getHWSurfaceData());
         } catch (InvalidPipeException var10) {
            Graphics var9 = var2.getGraphics();
            var9.drawImage(var3, 0, 0, var5, var6, (ImageObserver)null);
            var9.dispose();
         }

         if (var4 == FlipContents.BACKGROUND) {
            Graphics var8 = var3.getGraphics();
            var8.setColor(var2.getBackground());
            var8.fillRect(0, 0, var5, var6);
            var8.dispose();
         }

      }
   }

   static {
      initIDs();
      translucentCM = null;
   }
}