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 / java2d / SunGraphicsEnvironment.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  13.3 KB  |  617 lines
  1. package sun.java2d;
  2.  
  3. import java.awt.Color;
  4. import java.awt.Font;
  5. import java.awt.Graphics2D;
  6. import java.awt.GraphicsConfiguration;
  7. import java.awt.GraphicsDevice;
  8. import java.awt.GraphicsEnvironment;
  9. import java.awt.Insets;
  10. import java.awt.Rectangle;
  11. import java.awt.Toolkit;
  12. import java.awt.image.BufferedImage;
  13. import java.awt.print.PrinterJob;
  14. import java.io.File;
  15. import java.io.FilenameFilter;
  16. import java.io.IOException;
  17. import java.security.AccessController;
  18. import java.util.ArrayList;
  19. import java.util.Arrays;
  20. import java.util.HashSet;
  21. import java.util.Hashtable;
  22. import java.util.Locale;
  23. import java.util.NoSuchElementException;
  24. import java.util.StringTokenizer;
  25. import java.util.TreeMap;
  26. import java.util.logging.Level;
  27. import java.util.logging.Logger;
  28. import sun.awt.DisplayChangedListener;
  29. import sun.awt.FontConfiguration;
  30. import sun.awt.SunDisplayChanger;
  31. import sun.font.CompositeFontDescriptor;
  32. import sun.font.Font2D;
  33. import sun.font.FontManager;
  34. import sun.font.NativeFont;
  35. import sun.font.PhysicalFont;
  36.  
  37. public abstract class SunGraphicsEnvironment extends GraphicsEnvironment implements FontSupport, DisplayChangedListener {
  38.    public static boolean isLinux;
  39.    public static boolean isSolaris;
  40.    public static boolean noType1Font;
  41.    private static Font defaultFont;
  42.    private static String lucidaSansFileName;
  43.    public static final String lucidaFontName = "Lucida Sans Regular";
  44.    public static boolean debugFonts = false;
  45.    protected static Logger logger = null;
  46.    private static ArrayList badFonts;
  47.    public static String jreLibDirName;
  48.    public static String jreFontDirName;
  49.    private static HashSet<String> missingFontFiles = null;
  50.    private FontConfiguration fontConfig;
  51.    protected String fontPath;
  52.    private boolean discoveredAllFonts = false;
  53.    private boolean loadedAllFontFiles = false;
  54.    protected HashSet registeredFontFiles = new HashSet();
  55.    public static String eudcFontFileName;
  56.    protected GraphicsDevice[] screens;
  57.    private Font[] allFonts;
  58.    private static Locale systemLocale = null;
  59.    private String[] allFamilies;
  60.    private Locale lastDefaultLocale;
  61.    public static final TTFilter ttFilter = new TTFilter();
  62.    public static final T1Filter t1Filter = new T1Filter();
  63.    protected SunDisplayChanger displayChanger = new SunDisplayChanger();
  64.  
  65.    public SunGraphicsEnvironment() {
  66.       AccessController.doPrivileged(new 1(this));
  67.    }
  68.  
  69.    public synchronized GraphicsDevice[] getScreenDevices() {
  70.       GraphicsDevice[] var1 = this.screens;
  71.       if (var1 == null) {
  72.          int var2 = this.getNumScreens();
  73.          var1 = new GraphicsDevice[var2];
  74.  
  75.          for(int var3 = 0; var3 < var2; ++var3) {
  76.             var1[var3] = this.makeScreenDevice(var3);
  77.          }
  78.  
  79.          this.screens = var1;
  80.       }
  81.  
  82.       return var1;
  83.    }
  84.  
  85.    protected abstract int getNumScreens();
  86.  
  87.    protected abstract GraphicsDevice makeScreenDevice(int var1);
  88.  
  89.    public GraphicsDevice getDefaultScreenDevice() {
  90.       return this.getScreenDevices()[0];
  91.    }
  92.  
  93.    public Graphics2D createGraphics(BufferedImage var1) {
  94.       if (var1 == null) {
  95.          throw new NullPointerException("BufferedImage cannot be null");
  96.       } else {
  97.          SurfaceData var2 = SurfaceData.getDestSurfaceData(var1);
  98.          return new SunGraphics2D(var2, Color.white, Color.black, defaultFont);
  99.       }
  100.    }
  101.  
  102.    protected String getPlatformFontPath(boolean var1) {
  103.       return FontManager.getFontPath(var1);
  104.    }
  105.  
  106.    protected boolean useAbsoluteFontFileNames() {
  107.       return true;
  108.    }
  109.  
  110.    public String getDefaultFontFile() {
  111.       return lucidaSansFileName;
  112.    }
  113.  
  114.    public String getDefaultFontFaceName() {
  115.       return "Lucida Sans Regular";
  116.    }
  117.  
  118.    public void loadFonts() {
  119.       if (!this.discoveredAllFonts) {
  120.          synchronized("Lucida Sans Regular") {
  121.             if (debugFonts) {
  122.                Thread.dumpStack();
  123.                logger.info("SunGraphicsEnvironment.loadFonts() called");
  124.             }
  125.  
  126.             FontManager.initialiseDeferredFonts();
  127.             AccessController.doPrivileged(new 2(this));
  128.          }
  129.       }
  130.    }
  131.  
  132.    public void loadFontFiles() {
  133.       this.loadFonts();
  134.       if (!this.loadedAllFontFiles) {
  135.          synchronized("Lucida Sans Regular") {
  136.             if (debugFonts) {
  137.                Thread.dumpStack();
  138.                logger.info("loadAllFontFiles() called");
  139.             }
  140.  
  141.             AccessController.doPrivileged(new 3(this));
  142.          }
  143.       }
  144.    }
  145.  
  146.    private boolean isNameForRegisteredFile(String var1) {
  147.       String var2 = FontManager.getFileNameForFontName(var1);
  148.       return var2 == null ? false : this.registeredFontFiles.contains(var2);
  149.    }
  150.  
  151.    public Font[] getAllInstalledFonts() {
  152.       if (this.allFonts == null) {
  153.          this.loadFonts();
  154.          TreeMap var1 = new TreeMap();
  155.          Font2D[] var2 = FontManager.getRegisteredFonts();
  156.  
  157.          for(int var3 = 0; var3 < var2.length; ++var3) {
  158.             if (!(var2[var3] instanceof NativeFont)) {
  159.                var1.put(var2[var3].getFontName((Locale)null), var2[var3]);
  160.             }
  161.          }
  162.  
  163.          String[] var9 = FontManager.getFontNamesFromPlatform();
  164.          if (var9 != null) {
  165.             for(int var4 = 0; var4 < var9.length; ++var4) {
  166.                if (!this.isNameForRegisteredFile(var9[var4])) {
  167.                   var1.put(var9[var4], (Object)null);
  168.                }
  169.             }
  170.          }
  171.  
  172.          String[] var10 = null;
  173.          if (var1.size() > 0) {
  174.             var10 = new String[var1.size()];
  175.             Object[] var5 = var1.keySet().toArray();
  176.  
  177.             for(int var6 = 0; var6 < var5.length; ++var6) {
  178.                var10[var6] = (String)var5[var6];
  179.             }
  180.          }
  181.  
  182.          Font[] var11 = new Font[var10.length];
  183.  
  184.          for(int var12 = 0; var12 < var10.length; ++var12) {
  185.             var11[var12] = new Font(var10[var12], 0, 1);
  186.             Font2D var7 = (Font2D)var1.get(var10[var12]);
  187.             if (var7 != null) {
  188.                FontManager.setFont2D(var11[var12], var7.handle);
  189.             }
  190.          }
  191.  
  192.          this.allFonts = var11;
  193.       }
  194.  
  195.       Font[] var8 = new Font[this.allFonts.length];
  196.       System.arraycopy(this.allFonts, 0, var8, 0, this.allFonts.length);
  197.       return var8;
  198.    }
  199.  
  200.    public Font[] getAllFonts() {
  201.       Font[] var1 = this.getAllInstalledFonts();
  202.       Font[] var2 = FontManager.getCreatedFonts();
  203.       if (var2 != null && var2.length != 0) {
  204.          int var3 = var1.length + var2.length;
  205.          Font[] var4 = (Font[])Arrays.copyOf(var1, var3);
  206.          System.arraycopy(var2, 0, var4, var1.length, var2.length);
  207.          return var4;
  208.       } else {
  209.          return var1;
  210.       }
  211.    }
  212.  
  213.    public static Locale getSystemStartupLocale() {
  214.       if (systemLocale == null) {
  215.          systemLocale = (Locale)AccessController.doPrivileged(new 4());
  216.       }
  217.  
  218.       return systemLocale;
  219.    }
  220.  
  221.    protected void getJREFontFamilyNames(TreeMap<String, String> var1, Locale var2) {
  222.       FontManager.registerDeferredJREFonts(jreFontDirName);
  223.       PhysicalFont[] var3 = FontManager.getPhysicalFonts();
  224.  
  225.       for(int var4 = 0; var4 < var3.length; ++var4) {
  226.          if (!(var3[var4] instanceof NativeFont)) {
  227.             String var5 = var3[var4].getFamilyName(var2);
  228.             var1.put(var5.toLowerCase(var2), var5);
  229.          }
  230.       }
  231.  
  232.    }
  233.  
  234.    public String[] getInstalledFontFamilyNames(Locale var1) {
  235.       if (var1 == null) {
  236.          var1 = Locale.getDefault();
  237.       }
  238.  
  239.       if (this.allFamilies != null && this.lastDefaultLocale != null && var1.equals(this.lastDefaultLocale)) {
  240.          String[] var7 = new String[this.allFamilies.length];
  241.          System.arraycopy(this.allFamilies, 0, var7, 0, this.allFamilies.length);
  242.          return var7;
  243.       } else {
  244.          TreeMap var2 = new TreeMap();
  245.          String var3 = "Serif";
  246.          var2.put(var3.toLowerCase(), var3);
  247.          var3 = "SansSerif";
  248.          var2.put(var3.toLowerCase(), var3);
  249.          var3 = "Monospaced";
  250.          var2.put(var3.toLowerCase(), var3);
  251.          var3 = "Dialog";
  252.          var2.put(var3.toLowerCase(), var3);
  253.          var3 = "DialogInput";
  254.          var2.put(var3.toLowerCase(), var3);
  255.          if (var1.equals(getSystemStartupLocale()) && FontManager.getFamilyNamesFromPlatform(var2, var1)) {
  256.             this.getJREFontFamilyNames(var2, var1);
  257.          } else {
  258.             this.loadFontFiles();
  259.             PhysicalFont[] var4 = FontManager.getPhysicalFonts();
  260.  
  261.             for(int var5 = 0; var5 < var4.length; ++var5) {
  262.                if (!(var4[var5] instanceof NativeFont)) {
  263.                   String var6 = var4[var5].getFamilyName(var1);
  264.                   var2.put(var6.toLowerCase(var1), var6);
  265.                }
  266.             }
  267.          }
  268.  
  269.          String[] var12 = new String[var2.size()];
  270.          Object[] var13 = var2.keySet().toArray();
  271.  
  272.          for(int var14 = 0; var14 < var13.length; ++var14) {
  273.             var12[var14] = (String)var2.get(var13[var14]);
  274.          }
  275.  
  276.          if (var1.equals(Locale.getDefault())) {
  277.             this.lastDefaultLocale = var1;
  278.             this.allFamilies = new String[var12.length];
  279.             System.arraycopy(var12, 0, this.allFamilies, 0, this.allFamilies.length);
  280.          }
  281.  
  282.          return var12;
  283.       }
  284.    }
  285.  
  286.    public String[] getAvailableFontFamilyNames(Locale var1) {
  287.       String[] var2 = this.getInstalledFontFamilyNames(var1);
  288.       TreeMap var3 = FontManager.getCreatedFontFamilyNames();
  289.       if (var3 != null && var3.size() != 0) {
  290.          for(int var4 = 0; var4 < var2.length; ++var4) {
  291.             var3.put(var2[var4].toLowerCase(var1), var2[var4]);
  292.          }
  293.  
  294.          String[] var7 = new String[var3.size()];
  295.          Object[] var5 = var3.keySet().toArray();
  296.  
  297.          for(int var6 = 0; var6 < var5.length; ++var6) {
  298.             var7[var6] = (String)var3.get(var5[var6]);
  299.          }
  300.  
  301.          return var7;
  302.       } else {
  303.          return var2;
  304.       }
  305.    }
  306.  
  307.    public String[] getAvailableFontFamilyNames() {
  308.       return this.getAvailableFontFamilyNames(Locale.getDefault());
  309.    }
  310.  
  311.    protected String getFileNameFromPlatformName(String var1) {
  312.       return this.fontConfig.getFileNameFromPlatformName(var1);
  313.    }
  314.  
  315.    public PrinterJob getPrinterJob() {
  316.       (new Exception()).printStackTrace();
  317.       return null;
  318.    }
  319.  
  320.    protected void registerJREFontsWithPlatform(String var1) {
  321.    }
  322.  
  323.    public void register1dot0Fonts() {
  324.       AccessController.doPrivileged(new 5(this));
  325.    }
  326.  
  327.    protected void registerFontDirs(String var1) {
  328.    }
  329.  
  330.    public void registerFontsInDir(String var1) {
  331.       this.registerFontsInDir(var1, true, 2, true, false);
  332.    }
  333.  
  334.    private void registerFontsInDir(String var1, boolean var2, int var3, boolean var4, boolean var5) {
  335.       File var6 = new File(var1);
  336.       this.addDirFonts(var1, var6, ttFilter, 0, var2, var3 == 6 ? 3 : var3, var4, var5);
  337.       this.addDirFonts(var1, var6, t1Filter, 1, var2, var3 == 6 ? 4 : var3, var4, var5);
  338.    }
  339.  
  340.    private void registerFontsOnPath(String var1, boolean var2, int var3, boolean var4, boolean var5) {
  341.       StringTokenizer var6 = new StringTokenizer(var1, File.pathSeparator);
  342.  
  343.       try {
  344.          while(var6.hasMoreTokens()) {
  345.             this.registerFontsInDir(var6.nextToken(), var2, var3, var4, var5);
  346.          }
  347.       } catch (NoSuchElementException var8) {
  348.       }
  349.  
  350.    }
  351.  
  352.    protected void registerFontFile(String var1, String[] var2, int var3, boolean var4) {
  353.       if (!this.registeredFontFiles.contains(var1)) {
  354.          byte var5;
  355.          if (ttFilter.accept((File)null, var1)) {
  356.             var5 = 0;
  357.          } else if (t1Filter.accept((File)null, var1)) {
  358.             var5 = 1;
  359.          } else {
  360.             var5 = 5;
  361.          }
  362.  
  363.          this.registeredFontFiles.add(var1);
  364.          if (var4) {
  365.             FontManager.registerDeferredFont(var1, var1, var2, var5, false, var3);
  366.          } else {
  367.             FontManager.registerFontFile(var1, var2, var5, false, var3);
  368.          }
  369.  
  370.       }
  371.    }
  372.  
  373.    protected void registerFontDir(String var1) {
  374.    }
  375.  
  376.    protected String[] getNativeNames(String var1, String var2) {
  377.       return null;
  378.    }
  379.  
  380.    private void addDirFonts(String var1, File var2, FilenameFilter var3, int var4, boolean var5, int var6, boolean var7, boolean var8) {
  381.       String[] var9 = var2.list(var3);
  382.       if (var9 != null && var9.length != 0) {
  383.          String[] var10 = new String[var9.length];
  384.          String[][] var11 = new String[var9.length][];
  385.          int var12 = 0;
  386.  
  387.          for(int var13 = 0; var13 < var9.length; ++var13) {
  388.             File var14 = new File(var2, var9[var13]);
  389.             String var15 = null;
  390.             if (var8) {
  391.                try {
  392.                   var15 = var14.getCanonicalPath();
  393.                } catch (IOException var19) {
  394.                }
  395.             }
  396.  
  397.             if (var15 == null) {
  398.                var15 = var1 + File.separator + var9[var13];
  399.             }
  400.  
  401.             if (!this.registeredFontFiles.contains(var15)) {
  402.                if (badFonts != null && badFonts.contains(var15)) {
  403.                   if (debugFonts) {
  404.                      logger.warning("skip bad font " + var15);
  405.                   }
  406.                } else {
  407.                   this.registeredFontFiles.add(var15);
  408.                   if (debugFonts && logger.isLoggable(Level.INFO)) {
  409.                      String var16 = "Registering font " + var15;
  410.                      String[] var17 = this.getNativeNames(var15, (String)null);
  411.                      if (var17 == null) {
  412.                         var16 = var16 + " with no native name";
  413.                      } else {
  414.                         var16 = var16 + " with native name(s) " + var17[0];
  415.  
  416.                         for(int var18 = 1; var18 < var17.length; ++var18) {
  417.                            var16 = var16 + ", " + var17[var18];
  418.                         }
  419.                      }
  420.  
  421.                      logger.info(var16);
  422.                   }
  423.  
  424.                   var10[var12] = var15;
  425.                   var11[var12++] = this.getNativeNames(var15, (String)null);
  426.                }
  427.             }
  428.          }
  429.  
  430.          FontManager.registerFonts(var10, var11, var12, var4, var5, var6, var7);
  431.       }
  432.    }
  433.  
  434.    protected void addToMissingFontFileList(String var1) {
  435.       if (missingFontFiles == null) {
  436.          missingFontFiles = new HashSet();
  437.       }
  438.  
  439.       missingFontFiles.add(var1);
  440.    }
  441.  
  442.    protected abstract FontConfiguration createFontConfiguration();
  443.  
  444.    public abstract FontConfiguration createFontConfiguration(boolean var1, boolean var2);
  445.  
  446.    private void initCompositeFonts(FontConfiguration var1, Hashtable var2) {
  447.       int var3 = var1.getNumberCoreFonts();
  448.       String[] var4 = var1.getPlatformFontNames();
  449.  
  450.       for(int var5 = 0; var5 < var4.length; ++var5) {
  451.          String var6 = var4[var5];
  452.          String var7 = this.getFileNameFromPlatformName(var6);
  453.          String[] var8 = null;
  454.          if (var7 == null) {
  455.             var7 = var6;
  456.          } else {
  457.             if (var5 < var3) {
  458.                this.addFontToPlatformFontPath(var6);
  459.             }
  460.  
  461.             var8 = this.getNativeNames(var7, var6);
  462.          }
  463.  
  464.          this.registerFontFile(var7, var8, 2, true);
  465.       }
  466.  
  467.       this.registerPlatformFontsUsedByFontConfiguration();
  468.       CompositeFontDescriptor[] var11 = var1.get2DCompositeFontInfo();
  469.  
  470.       for(int var12 = 0; var12 < var11.length; ++var12) {
  471.          CompositeFontDescriptor var13 = var11[var12];
  472.          String[] var14 = var13.getComponentFileNames();
  473.          String[] var9 = var13.getComponentFaceNames();
  474.          if (missingFontFiles != null) {
  475.             for(int var10 = 0; var10 < var14.length; ++var10) {
  476.                if (missingFontFiles.contains(var14[var10])) {
  477.                   var14[var10] = this.getDefaultFontFile();
  478.                   var9[var10] = this.getDefaultFontFaceName();
  479.                }
  480.             }
  481.          }
  482.  
  483.          if (var2 != null) {
  484.             FontManager.registerCompositeFont(var13.getFaceName(), var14, var9, var13.getCoreComponentCount(), var13.getExclusionRanges(), var13.getExclusionRangeLimits(), true, var2);
  485.          } else {
  486.             FontManager.registerCompositeFont(var13.getFaceName(), var14, var9, var13.getCoreComponentCount(), var13.getExclusionRanges(), var13.getExclusionRangeLimits(), true);
  487.          }
  488.  
  489.          if (debugFonts) {
  490.             logger.info("registered " + var13.getFaceName());
  491.          }
  492.       }
  493.  
  494.    }
  495.  
  496.    protected void addFontToPlatformFontPath(String var1) {
  497.    }
  498.  
  499.    protected void registerPlatformFontsUsedByFontConfiguration() {
  500.    }
  501.  
  502.    public static boolean isLogicalFont(Font var0) {
  503.       return FontConfiguration.isLogicalFontFamilyName(var0.getFamily());
  504.    }
  505.  
  506.    public FontConfiguration getFontConfiguration() {
  507.       return this.fontConfig;
  508.    }
  509.  
  510.    public static Rectangle getUsableBounds(GraphicsDevice var0) {
  511.       GraphicsConfiguration var1 = var0.getDefaultConfiguration();
  512.       Insets var2 = Toolkit.getDefaultToolkit().getScreenInsets(var1);
  513.       Rectangle var3 = var1.getBounds();
  514.       var3.x += var2.left;
  515.       var3.y += var2.top;
  516.       var3.width -= var2.left + var2.right;
  517.       var3.height -= var2.top + var2.bottom;
  518.       return var3;
  519.    }
  520.  
  521.    public static boolean fontSupportsDefaultEncoding(Font var0) {
  522.       return FontManager.fontSupportsDefaultEncoding(var0);
  523.    }
  524.  
  525.    public static void useAlternateFontforJALocales() {
  526.       FontManager.useAlternateFontforJALocales();
  527.    }
  528.  
  529.    public void createCompositeFonts(Hashtable var1, boolean var2, boolean var3) {
  530.       FontConfiguration var4 = this.createFontConfiguration(var2, var3);
  531.       this.initCompositeFonts(var4, var1);
  532.    }
  533.  
  534.    protected void getPlatformFontPathFromFontConfig() {
  535.    }
  536.  
  537.    public void displayChanged() {
  538.       for(GraphicsDevice var4 : this.getScreenDevices()) {
  539.          if (var4 instanceof DisplayChangedListener) {
  540.             ((DisplayChangedListener)var4).displayChanged();
  541.          }
  542.       }
  543.  
  544.       this.displayChanger.notifyListeners();
  545.    }
  546.  
  547.    public void paletteChanged() {
  548.       this.displayChanger.notifyPaletteChanged();
  549.    }
  550.  
  551.    public void addDisplayChangedListener(DisplayChangedListener var1) {
  552.       this.displayChanger.add(var1);
  553.    }
  554.  
  555.    public void removeDisplayChangedListener(DisplayChangedListener var1) {
  556.       this.displayChanger.remove(var1);
  557.    }
  558.  
  559.    // $FF: synthetic method
  560.    static String access$002(String var0) {
  561.       lucidaSansFileName = var0;
  562.       return var0;
  563.    }
  564.  
  565.    // $FF: synthetic method
  566.    static ArrayList access$102(ArrayList var0) {
  567.       badFonts = var0;
  568.       return var0;
  569.    }
  570.  
  571.    // $FF: synthetic method
  572.    static ArrayList access$100() {
  573.       return badFonts;
  574.    }
  575.  
  576.    // $FF: synthetic method
  577.    static void access$200(SunGraphicsEnvironment var0, String var1, boolean var2, int var3, boolean var4, boolean var5) {
  578.       var0.registerFontsInDir(var1, var2, var3, var4, var5);
  579.    }
  580.  
  581.    // $FF: synthetic method
  582.    static FontConfiguration access$302(SunGraphicsEnvironment var0, FontConfiguration var1) {
  583.       return var0.fontConfig = var1;
  584.    }
  585.  
  586.    // $FF: synthetic method
  587.    static FontConfiguration access$300(SunGraphicsEnvironment var0) {
  588.       return var0.fontConfig;
  589.    }
  590.  
  591.    // $FF: synthetic method
  592.    static void access$400(SunGraphicsEnvironment var0, FontConfiguration var1, Hashtable var2) {
  593.       var0.initCompositeFonts(var1, var2);
  594.    }
  595.  
  596.    // $FF: synthetic method
  597.    static Font access$502(Font var0) {
  598.       defaultFont = var0;
  599.       return var0;
  600.    }
  601.  
  602.    // $FF: synthetic method
  603.    static void access$600(SunGraphicsEnvironment var0, String var1, boolean var2, int var3, boolean var4, boolean var5) {
  604.       var0.registerFontsOnPath(var1, var2, var3, var4, var5);
  605.    }
  606.  
  607.    // $FF: synthetic method
  608.    static boolean access$702(SunGraphicsEnvironment var0, boolean var1) {
  609.       return var0.loadedAllFontFiles = var1;
  610.    }
  611.  
  612.    // $FF: synthetic method
  613.    static boolean access$802(SunGraphicsEnvironment var0, boolean var1) {
  614.       return var0.discoveredAllFonts = var1;
  615.    }
  616. }
  617.