S283 Planetary Science &… the Search for Life CD 3/0_CD-ROM.iso/install/jre1_3/lib/rt.jar/sun/java2d/SunGraphicsEnvironment.class

Java Class File | 1979-12-31 | 11.6 KB | 656 lines

package sun.java2d;

import java.awt.Component;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.font.TextAttribute;
import java.awt.image.BufferedImage;
import java.awt.print.PrinterJob;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FilenameFilter;
import java.io.InputStream;
import java.security.AccessController;
import java.text.AttributedCharacterIterator;
import java.util.Hashtable;
import java.util.Locale;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.NoSuchElementException;
import java.util.Properties;
import java.util.ResourceBundle;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.Vector;
import sun.awt.font.NativeFontWrapper;
import sun.awt.image.BufferedImageGraphics2D;
import sun.io.CharacterEncoding;

public abstract class SunGraphicsEnvironment extends GraphicsEnvironment {
   private static final boolean debugMapping = false;
   private Properties fprops;
   private TreeMap terminalNames;
   private boolean loadedAllFonts = false;
   protected String fontPath;
   protected TreeMap registeredFonts = new TreeMap();
   protected String osVersion = this.getOsVersion();
   private Hashtable mapFamilyCache;
   protected boolean loadNativeFonts = false;
   GraphicsDevice[] screens;
   private Font[] allFonts;
   private static final String systemBundle = "java.text.resources.LocaleElements";

   public SunGraphicsEnvironment() {
      AccessController.doPrivileged(new 1(this));
   }

   protected String getOsVersion() {
      return System.getProperty("os.version");
   }

   protected synchronized void loadFonts() {
      if (!this.loadedAllFonts) {
         AccessController.doPrivileged(new 2(this));
      }
   }

   public synchronized GraphicsDevice[] getScreenDevices() {
      GraphicsDevice[] var1 = this.screens;
      if (var1 == null) {
         int var2 = this.getNumScreens();
         var1 = new GraphicsDevice[var2];

         for(int var3 = 0; var3 < var2; ++var3) {
            var1[var3] = this.makeScreenDevice(var3);
         }

         this.screens = var1;
      }

      return var1;
   }

   protected abstract int getNumScreens();

   protected abstract GraphicsDevice makeScreenDevice(int var1);

   public GraphicsDevice getDefaultScreenDevice() {
      return this.getScreenDevices()[0];
   }

   public Graphics2D createGraphics(BufferedImage var1) {
      return new BufferedImageGraphics2D(var1, (Component)null);
   }

   public Font[] getAllFonts() {
      if (this.allFonts != null) {
         return this.allFonts;
      } else {
         this.loadFonts();
         Font[] var1 = null;
         String[] var2 = null;
         int var3 = NativeFontWrapper.getNumFonts();
         if (var3 > 0) {
            TreeMap var4 = new TreeMap();

            for(int var5 = 0; var5 < var3; ++var5) {
               String var6 = NativeFontWrapper.getFullNameByIndex(var5);
               var4.put(var6, (Object)null);
            }

            if (var4.size() > 0) {
               var2 = new String[var4.size()];
               Object[] var9 = var4.keySet().toArray();

               for(int var7 = 0; var7 < var9.length; ++var7) {
                  var2[var7] = (String)var9[var7];
               }
            }
         }

         if (var2 != null) {
            var1 = new Font[var2.length];

            for(int var8 = 0; var8 < var2.length; ++var8) {
               var1[var8] = new Font(var2[var8], 0, 1);
            }
         }

         this.allFonts = var1;
         return this.allFonts;
      }
   }

   public String[] getAvailableFontFamilyNames(Locale var1) {
      this.loadFonts();
      String[] var2 = null;
      int var3 = NativeFontWrapper.getNumFonts();
      short var4 = getLcidFromLocale(var1);
      if (var3 > 0) {
         TreeMap var5 = new TreeMap();

         for(int var6 = 0; var6 < var3; ++var6) {
            String var7 = NativeFontWrapper.getFamilyNameByIndex(var6, var4);
            String var8 = var7.toLowerCase();
            if (!var8.endsWith(".bold") && !var8.endsWith(".bolditalic") && !var8.endsWith(".italic")) {
               var5.put(var8, var7);
            }
         }

         String var10 = "Serif";
         var5.put(var10.toLowerCase(), var10);
         var10 = "SansSerif";
         var5.put(var10.toLowerCase(), var10);
         var10 = "Monospaced";
         var5.put(var10.toLowerCase(), var10);
         var10 = "Dialog";
         var5.put(var10.toLowerCase(), var10);
         var10 = "DialogInput";
         var5.put(var10.toLowerCase(), var10);
         var10 = "Default";
         var5.put(var10.toLowerCase(), var10);
         if (var5.size() > 0) {
            var2 = new String[var5.size()];
            Object[] var16 = var5.keySet().toArray();

            for(int var9 = 0; var9 < var16.length; ++var9) {
               var2[var9] = (String)var5.get(var16[var9]);
            }
         }
      }

      return var2;
   }

   public String[] getAvailableFontFamilyNames() {
      return this.getAvailableFontFamilyNames(Locale.getDefault());
   }

   public String mapFamilyName(String var1, int var2) {
      String var4 = var1.toLowerCase(Locale.ENGLISH);
      if (!this.terminalNames.containsKey(var4)) {
         this.loadFonts();
      }

      String var3 = this.mapFamilyNameAll(var1, var2);
      return var3;
   }

   public String mapFamilyNameAll(String var1, int var2) {
      String var3 = var1.toLowerCase();
      if (null != this.mapFamilyCache) {
         String var4 = (String)this.mapFamilyCache.get(var3 + styleStr(var2));
         if (null != var4) {
            return var4;
         }
      }

      if (this.fprops == null) {
         return var1;
      } else {
         String var11 = this.fprops.getProperty("alias." + var3);
         if (var11 == null) {
            var11 = var1;
         }

         Object[] var5 = this.fprops.keySet().toArray();
         int var6 = var5.length;
         int var7 = 0;

         do {
            String var8 = var11.toLowerCase();
            if (this.terminalNames.containsKey(var8 + "." + styleStr(var2))) {
               var11 = var8 + "." + styleStr(var2);
               break;
            }

            if (var2 == 0 && this.terminalNames.containsKey(var8)) {
               break;
            }

            String var9 = var8 + "." + styleStr(var2) + ".0";
            String var10 = this.fprops.getProperty(var9);
            if (var10 == null) {
               var9 = var8 + ".0";
               var10 = this.fprops.getProperty(var9);
            }

            if (var10 == null) {
               break;
            }

            var11 = this.parseFamilyNameProperty(var10);
            ++var7;
         } while(var7 < var6);

         if (null == this.mapFamilyCache) {
            this.mapFamilyCache = new Hashtable(5, 0.9F);
         }

         if (null != this.mapFamilyCache) {
            this.mapFamilyCache.put(var3 + styleStr(var2), var11);
         }

         return var11;
      }
   }

   protected String parseFamilyNameProperty(String var1) {
      int var2 = var1.indexOf(",");
      if (var2 == -1) {
         var2 = var1.length();
      }

      return var1.substring(0, var2);
   }

   protected String getFontPropertyFD(String var1) {
      return this.parseFamilyNameProperty(var1);
   }

   protected String getFileNameFromPlatformName(String var1) {
      if (this.fprops == null) {
         return null;
      } else {
         var1 = var1.replace(' ', '_');
         return this.fprops.getProperty("filename." + var1);
      }
   }

   public PrinterJob getPrinterJob() {
      (new Exception()).printStackTrace();
      return null;
   }

   private boolean registerFonts(String var1) {
      boolean var2 = false;
      StringTokenizer var3 = new StringTokenizer(var1, File.pathSeparator);

      try {
         while(var3.hasMoreTokens()) {
            String var4 = var3.nextToken();
            this.registerFontPath(var4);
            var2 |= this.addPathFonts(var4, new TTFilter(this), 0);
            var2 |= this.addPathFonts(var4, new T1Filter(this), 1);
            var2 |= this.addPathFonts(var4, new T2KFilter(this), 2);
         }
      } catch (NoSuchElementException var5) {
         System.err.println(var5);
      }

      return var2;
   }

   private void registerFontFile(String var1, String var2) {
      if (!this.registeredFonts.containsKey(var1)) {
         byte var3;
         if ((new TTFilter(this)).accept((File)null, var1)) {
            var3 = 0;
         } else if ((new T1Filter(this)).accept((File)null, var1)) {
            var3 = 1;
         } else {
            if (!(new T2KFilter(this)).accept((File)null, var1)) {
               this.registerNative(var1);
               return;
            }

            var3 = 2;
         }

         StringTokenizer var4 = new StringTokenizer(this.fontPath, File.pathSeparator);

         try {
            while(var4.hasMoreTokens()) {
               String var5 = var4.nextToken();
               File var6 = new File(var5, var1);
               if (var6.canRead()) {
                  Vector var7 = new Vector(20, 10);
                  Vector var8 = new Vector(20, 10);
                  var8.addElement(var2);
                  var7.addElement(var6.getAbsolutePath());
                  this.registeredFonts.put(var1, var6.getAbsolutePath());
                  NativeFontWrapper.registerFonts(var7, var7.size(), var8, var3);
                  break;
               }
            }
         } catch (NoSuchElementException var9) {
            System.err.println(var9);
         }

      }
   }

   protected void registerFontPath(String var1) {
   }

   protected void registerNative(String var1) {
   }

   protected String getPropString(String var1) {
      return var1;
   }

   protected boolean registerNativeFonts() {
      return false;
   }

   private boolean addPathFonts(String var1, FilenameFilter var2, int var3) {
      boolean var4 = false;
      Vector var5 = new Vector(20, 10);
      Vector var6 = new Vector(20, 10);
      File var7 = new File(var1);
      String[] var8 = var7.list(var2);
      if (var8 == null) {
         return var4;
      } else {
         for(int var9 = 0; var9 < var8.length; ++var9) {
            File var10 = new File(var7, var8[var9]);
            if (!this.registeredFonts.containsKey(var8[var9])) {
               String var11 = var10.getAbsolutePath();
               this.registeredFonts.put(var8[var9], var11);
               var5.addElement(var11);
               var6.addElement(this.getPropString(var11));
               var4 = true;
            }
         }

         NativeFontWrapper.registerFonts(var5, var5.size(), var6, var3);
         return var4;
      }
   }

   public static Font getBestFontFor(AttributedCharacterIterator var0, int var1, int var2) {
      char var3 = var0.setIndex(var1);
      Map var4 = var0.getAttributes();

      Font var5;
      for(var5 = Font.getFont(var4); !var5.canDisplay(var3) && var0.getRunLimit() < var2; var5 = Font.getFont(var0.getAttributes())) {
         var0.setIndex(var0.getRunLimit());
      }

      if (!var5.canDisplay(var3)) {
         var0.setIndex(var1);
         String[] var6 = GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames();

         for(int var7 = 0; var7 < var6.length; ++var7) {
            Hashtable var8 = new Hashtable();
            var8.putAll(var4);
            var8.put(TextAttribute.FAMILY, var6[var7]);
            var5 = Font.getFont(var8);
            if (var5.canDisplay(var3)) {
               break;
            }
         }

         if (!var5.canDisplay(var3)) {
            var5 = Font.getFont(var4);
         }
      }

      return var5;
   }

   protected boolean platformReady() {
      return true;
   }

   private File tryOpeningFontProp(File var1, String var2, String var3, String var4) {
      if (var1 != null) {
         return var1;
      } else {
         String var5 = var2 + File.separator + "lib" + File.separator + "font.properties";
         if (var3 != null) {
            var5 = var5 + "." + var3;
            if (var4 != null) {
               var5 = var5 + "_" + var4;
            }
         }

         File var6 = new File(var5 + "." + this.osVersion);
         if (var6 != null && var6.canRead()) {
            return var6;
         } else {
            var6 = new File(var5);
            return var6 != null && var6.canRead() ? var6 : null;
         }
      }
   }

   private void appendJavaDefaultFontPath() {
      String var1 = System.getProperty("java.home") + File.separator + "lib" + File.separator + "fonts";
      if (var1 != null) {
         this.fontPath = this.fontPath + File.pathSeparator + var1;
      }

   }

   private void initializeProps() {
      if (this.platformReady()) {
         String var1 = System.getProperty("user.home");
         String var2 = System.getProperty("java.home");
         if (var2 == null) {
            throw new Error("java.home property not set");
         } else {
            String var3 = System.getProperty("user.language", "en");
            String var4 = System.getProperty("user.region");
            String var5 = System.getProperty("file.encoding");
            String var6 = CharacterEncoding.aliasName(var5);
            if (var6 == null) {
               var6 = var5;
            }

            try {
               File var7 = null;
               if (var4 != null) {
                  var7 = this.tryOpeningFontProp(var7, var1, var3, var4 + "_" + var6);
                  var7 = this.tryOpeningFontProp(var7, var2, var3, var4 + "_" + var6);
                  var7 = this.tryOpeningFontProp(var7, var1, var3, var4);
                  var7 = this.tryOpeningFontProp(var7, var2, var3, var4);
               }

               var7 = this.tryOpeningFontProp(var7, var1, var3, var6);
               var7 = this.tryOpeningFontProp(var7, var2, var3, var6);
               var7 = this.tryOpeningFontProp(var7, var1, var3, (String)null);
               var7 = this.tryOpeningFontProp(var7, var2, var3, (String)null);
               var7 = this.tryOpeningFontProp(var7, var1, var6, (String)null);
               var7 = this.tryOpeningFontProp(var7, var2, var6, (String)null);
               var7 = this.tryOpeningFontProp(var7, var1, (String)null, (String)null);
               var7 = this.tryOpeningFontProp(var7, var2, (String)null, (String)null);
               Properties var8 = new Properties();
               ((Hashtable)var8).put("serif.0", "unknown");
               ((Hashtable)var8).put("sansserif.0", "unknown");
               ((Hashtable)var8).put("monospaced.0", "unknown");
               ((Hashtable)var8).put("dialog.0", "unknown");
               ((Hashtable)var8).put("dialoginput.0", "unknown");
               ((Hashtable)var8).put("default.0", "sansserif");
               ((Hashtable)var8).put("timesroman.0", "serif");
               ((Hashtable)var8).put("helvetica.0", "sansserif");
               ((Hashtable)var8).put("courier.0", "monospaced");
               ((Hashtable)var8).put("zapfdingbats.0", "unknown");
               this.fprops = new Properties(var8);
               if (var7 != null) {
                  BufferedInputStream var9 = new BufferedInputStream(new FileInputStream(var7.getPath()));
                  this.fprops.load(var9);
                  ((InputStream)var9).close();
               }
            } catch (Exception var10) {
            }

         }
      }
   }

   protected void initCompositeFonts() {
      if (this.platformReady()) {
         this.initTerminalNames();
         Object[] var1 = this.terminalNames.keySet().toArray();

         for(int var2 = 0; var2 < var1.length; ++var2) {
            String var3 = (String)var1[var2];
            Integer var4 = (Integer)this.terminalNames.get(var1[var2]);
            int var5 = var4;
            String[] var6 = new String[var5];
            int[] var7 = new int[var5];
            int[] var8 = new int[0];

            for(int var9 = 0; var9 < var5; ++var9) {
               var6[var9] = this.parseFamilyNameProperty(this.fprops.getProperty(var3 + "." + var9));
               var8 = this.appendExclusions(var3, var9, var8);
               var7[var9] = var8.length;
            }

            NativeFontWrapper.registerCompositeFont(var3, var6, var8, var7);
         }

         this.terminalNames.put("default", new Integer(0));
      }
   }

   private int[] appendExclusions(String var1, int var2, int[] var3) {
      String var4 = "exclusion." + var1 + "." + var2;
      if (this.fprops.containsKey(var4)) {
         String var5 = this.fprops.getProperty(var4);
         int var6 = (var5.length() + 1) / 10;
         if (var6 > 0) {
            int[] var7 = new int[var6 * 2];

            for(int var8 = 0; var8 < var6; ++var8) {
               String var9 = var5.substring(var8 * 10, var8 * 10 + 4);
               String var10 = var5.substring(var8 * 10 + 5, var8 * 10 + 9);
               var7[var8 * 2] = Integer.parseInt(var9, 16);
               var7[var8 * 2 + 1] = Integer.parseInt(var10, 16);
            }

            int var11 = var3.length + var7.length;
            int[] var12 = new int[var11];
            System.arraycopy(var3, 0, var12, 0, var3.length);
            System.arraycopy(var7, 0, var12, var3.length, var7.length);
            var3 = var12;
         }
      }

      return var3;
   }

   private void initTerminalNames() {
      TreeMap var1 = new TreeMap();
      TreeMap var2 = new TreeMap();
      this.terminalNames = new TreeMap();
      String var3 = "Serif";
      var1.put(var3.toLowerCase(Locale.ENGLISH), var3);
      var3 = "SansSerif";
      var1.put(var3.toLowerCase(Locale.ENGLISH), var3);
      var3 = "Monospaced";
      var1.put(var3.toLowerCase(Locale.ENGLISH), var3);
      var3 = "Dialog";
      var1.put(var3.toLowerCase(Locale.ENGLISH), var3);
      var3 = "DialogInput";
      var1.put(var3.toLowerCase(Locale.ENGLISH), var3);
      Object[] var4 = this.fprops.keySet().toArray();

      for(int var5 = 0; var5 < var4.length; ++var5) {
         String var6 = (String)var4[var5];
         int var7 = var6.indexOf(".");
         if (var7 == -1) {
            var7 = var6.length();
         }

         String var8 = var6.substring(0, var7);
         if (var1.containsKey(var8)) {
            var7 = var6.lastIndexOf(".");
            if (var7 != -1) {
               String var9 = var6.substring(0, var7);
               if (!this.terminalNames.containsKey(var9) && this.fprops.containsKey(var9 + ".0")) {
                  int var10;
                  for(var10 = 0; this.fprops.containsKey(var9 + "." + var10); ++var10) {
                  }

                  if (var10 != 0) {
                     this.terminalNames.put(var9, new Integer(var10));

                     for(int var11 = 0; var11 < var10; ++var11) {
                        String var12 = this.getFontPropertyFD(this.fprops.getProperty(var9 + "." + var11));
                        String var13 = this.getFileNameFromPlatformName(var12);
                        if (var13 == null) {
                           System.err.println("Font specified in font.properties not found [" + var12 + "]");
                           this.loadFonts();
                           break;
                        }

                        if (!var2.containsKey(var13)) {
                           var2.put(var13, (Object)null);
                           this.registerFontFile(var13, var12);
                        }
                     }
                  }
               }
            }
         }
      }

   }

   public static String styleStr(int var0) {
      switch (var0) {
         case 1:
            return "bold";
         case 2:
            return "italic";
         case 3:
            return "bolditalic";
         default:
            return "plain";
      }
   }

   public static String createFont(File var0) {
      String var1 = NativeFontWrapper.createFont(var0.getAbsolutePath(), 0);
      return var1;
   }

   private static short getLcidFromLocale(Locale var0) {
      short var1 = 1033;
      if (var0.equals(Locale.US)) {
         return var1;
      } else {
         String var2;
         try {
            ResourceBundle var3 = ResourceBundle.getBundle("java.text.resources.LocaleElements", var0);
            var2 = var3.getString("LocaleID");
         } catch (MissingResourceException var5) {
            return var1;
         }

         try {
            var1 = (short)Integer.parseInt(var2, 16);
         } catch (NumberFormatException var4) {
         }

         return var1;
      }
   }

   // $FF: synthetic method
   static void access$000(SunGraphicsEnvironment var0) {
      var0.appendJavaDefaultFontPath();
   }

   // $FF: synthetic method
   static void access$100(SunGraphicsEnvironment var0) {
      var0.initializeProps();
   }

   // $FF: synthetic method
   static boolean access$200(SunGraphicsEnvironment var0, String var1) {
      return var0.registerFonts(var1);
   }

   // $FF: synthetic method
   static boolean access$302(SunGraphicsEnvironment var0, boolean var1) {
      return var0.loadedAllFonts = var1;
   }
}