像词语一般的特殊字体选择器 : 字体选择 « Swing组件 « Java

En
Java
1. 图形用户界面
2. 三维图形动画
3. 高级图形
4. 蚂蚁编译
5. Apache类库
6. 统计图
7. 
8. 集合数据结构
9. 数据类型
10. 数据库JDBC
11. 设计模式
12. 开发相关类
13. EJB3
14. 电子邮件
15. 事件
16. 文件输入输出
17. 游戏
18. 泛型
19. GWT
20. Hibernate
21. 本地化
22. J2EE平台
23. 基于J2ME
24. JDK-6
25. JNDI的LDAP
26. JPA
27. JSP技术
28. JSTL
29. 语言基础知识
30. 网络协议
31. PDF格式RTF格式
32. 映射
33. 常规表达式
34. 脚本
35. 安全
36. Servlets
37. Spring
38. Swing组件
39. 图形用户界面
40. SWT-JFace-Eclipse
41. 线程
42. 应用程序
43. Velocity
44. Web服务SOA
45. 可扩展标记语言
Java 教程
Java » Swing组件 » 字体选择屏幕截图 
像词语一般的特殊字体选择器
 

/*
 * @(#)Font2DTest.java  1.28 05/11/17
 
 * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 
 * -Redistribution of source code must retain the above copyright notice, this
 *  list of conditions and the following disclaimer.
 
 * -Redistribution in binary form must reproduce the above copyright notice, 
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 
 * Neither the name of Sun Microsystems, Inc. or the names of contributors may 
 * be used to endorse or promote products derived from this software without 
 * specific prior written permission.
 
 * This software is provided "AS IS," without a warranty of any kind. ALL 
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING
 * ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
 * OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MIDROSYSTEMS, INC. ("SUN")
 * AND ITS LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE
 * AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS
 * DERIVATIVES. IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST 
 * REVENUE, PROFIT OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, 
 * INCIDENTAL OR PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY 
 * OF LIABILITY, ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, 
 * EVEN IF SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 
 * You acknowledge that this software is not designed, licensed or intended
 * for use in the design, construction, operation or maintenance of any
 * nuclear facility.
 */

/*
 * @(#)Font2DTest.java  1.28 05/11/17
 */

import static java.awt.RenderingHints.KEY_ANTIALIASING;
import static java.awt.RenderingHints.KEY_FRACTIONALMETRICS;
import static java.awt.RenderingHints.KEY_TEXT_ANTIALIASING;
import static java.awt.RenderingHints.KEY_TEXT_LCD_CONTRAST;
import static java.awt.RenderingHints.VALUE_ANTIALIAS_OFF;
import static java.awt.RenderingHints.VALUE_ANTIALIAS_ON;
import static java.awt.RenderingHints.VALUE_FRACTIONALMETRICS_DEFAULT;
import static java.awt.RenderingHints.VALUE_FRACTIONALMETRICS_OFF;
import static java.awt.RenderingHints.VALUE_FRACTIONALMETRICS_ON;
import static java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT;
import static java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_GASP;
import static java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HBGR;
import static java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_HRGB;
import static java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_VBGR;
import static java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_LCD_VRGB;
import static java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_OFF;
import static java.awt.RenderingHints.VALUE_TEXT_ANTIALIAS_ON;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Container;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsEnvironment;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.GridLayout;
import java.awt.Insets;
import java.awt.Point;
import java.awt.RenderingHints;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.AdjustmentEvent;
import java.awt.event.AdjustmentListener;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.font.FontRenderContext;
import java.awt.font.GlyphVector;
import java.awt.font.LineBreakMeasurer;
import java.awt.font.TextLayout;
import java.awt.geom.AffineTransform;
import java.awt.geom.NoninvertibleTransformException;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.awt.print.PageFormat;
import java.awt.print.Printable;
import java.awt.print.PrinterJob;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.text.AttributedString;
import java.util.BitSet;
import java.util.EnumSet;
import java.util.StringTokenizer;
import java.util.Vector;

import javax.imageio.ImageIO;
import javax.swing.ButtonGroup;
import javax.swing.DefaultListCellRenderer;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JCheckBoxMenuItem;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JDialog;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JScrollBar;
import javax.swing.JScrollPane;
import javax.swing.JSlider;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.JWindow;
import javax.swing.UIManager;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

/**
 * Font2DTest.java
 
 @version
 * @(#)Font2DTest.java 1.2 00/08/22
 @author Shinsuke Fukuda
 @author Ankit Patel [Conversion to Swing - 01/07/30]
 */

// / Main Font2DTest Class
public final class Font2DTest extends JPanel implements ActionListener, ItemListener,
    ChangeListener {

  // / JFrame that will contain Font2DTest
  private final JFrame parent;

  // / FontPanel class that will contain all graphical output
  private final FontPanel fp;

  // / RangeMenu class that contains info about the unicode ranges
  private final RangeMenu rm;

  // / Other menus to set parameters for text drawing
  private final ChoiceV2 fontMenu;

  private final JTextField sizeField;

  private final ChoiceV2 styleMenu;

  private final ChoiceV2 textMenu;

  private int currentTextChoice = 0;

  private final ChoiceV2 transformMenu;

  private final ChoiceV2 transformMenuG2;

  private final ChoiceV2 methodsMenu;

  private final JComboBox antiAliasMenu;

  private final JComboBox fracMetricsMenu;

  private final JSlider contrastSlider;

  // / CheckboxMenuItems
  private CheckboxMenuItemV2 displayGridCBMI;

  private CheckboxMenuItemV2 force16ColsCBMI;

  private CheckboxMenuItemV2 showFontInfoCBMI;

  // / JDialog boxes
  private JDialog userTextDialog;

  private JTextArea userTextArea;

  private JDialog printDialog;

  private JDialog fontInfoDialog;

  private LabelV2 fontInfos[] new LabelV2[2];

  private JFileChooser filePromptDialog = null;

  private ButtonGroup printCBGroup;

  private JRadioButton printModeCBs[] new JRadioButton[3];

  // / Status bar
  private final LabelV2 statusBar;

  private int fontStyles[] Font.PLAIN, Font.BOLD, Font.ITALIC, Font.BOLD | Font.ITALIC };

  // / Text filename
  private String tFileName;

  // Enabled or disabled status of canDisplay check
  private static boolean canDisplayCheck = true;

  // / Initialize GUI variables and its layouts
  public Font2DTest(JFrame f, boolean isApplet) {
    parent = f;

    rm = new RangeMenu(this, parent);
    fp = new FontPanel(this, parent);
    statusBar = new LabelV2("");

    fontMenu = new ChoiceV2(this, canDisplayCheck);
    sizeField = new JTextField("12"3);
    sizeField.addActionListener(this);
    styleMenu = new ChoiceV2(this);
    textMenu = new ChoiceV2()// listener added later
    transformMenu = new ChoiceV2(this);
    transformMenuG2 = new ChoiceV2(this);
    methodsMenu = new ChoiceV2(this);

    antiAliasMenu = new JComboBox(EnumSet.allOf(FontPanel.AAValues.class).toArray());
    antiAliasMenu.addActionListener(this);
    fracMetricsMenu = new JComboBox(EnumSet.allOf(FontPanel.FMValues.class).toArray());
    fracMetricsMenu.addActionListener(this);

    contrastSlider = new JSlider(JSlider.HORIZONTAL, 100250, FontPanel.getDefaultLCDContrast()
        .intValue());
    contrastSlider.setEnabled(false);
    contrastSlider.setMajorTickSpacing(20);
    contrastSlider.setMinorTickSpacing(10);
    contrastSlider.setPaintTicks(true);
    contrastSlider.setPaintLabels(true);
    contrastSlider.addChangeListener(this);
    setupPanel();
    setupMenu(isApplet);
    setupDialog(isApplet);

    if (canDisplayCheck) {
      fireRangeChanged();
    }
  }

  // / Set up the main interface panel
  private void setupPanel() {
    GridBagLayout gbl = new GridBagLayout();
    GridBagConstraints gbc = new GridBagConstraints();
    gbc.fill = GridBagConstraints.HORIZONTAL;
    gbc.weightx = 1;
    gbc.insets = new Insets(2022);
    this.setLayout(gbl);

    addLabeledComponentToGBL("Font: ", fontMenu, gbl, gbc, this);
    addLabeledComponentToGBL("Size: ", sizeField, gbl, gbc, this);
    gbc.gridwidth = GridBagConstraints.REMAINDER;
    addLabeledComponentToGBL("Font Transform:", transformMenu, gbl, gbc, this);
    gbc.gridwidth = 1;

    addLabeledComponentToGBL("Range: ", rm, gbl, gbc, this);
    addLabeledComponentToGBL("Style: ", styleMenu, gbl, gbc, this);
    gbc.gridwidth = GridBagConstraints.REMAINDER;
    addLabeledComponentToGBL("Graphics Transform: ", transformMenuG2, gbl, gbc, this);
    gbc.gridwidth = 1;

    gbc.anchor = GridBagConstraints.WEST;
    addLabeledComponentToGBL("Method: ", methodsMenu, gbl, gbc, this);
    addLabeledComponentToGBL("", null, gbl, gbc, this);
    gbc.anchor = GridBagConstraints.EAST;
    gbc.gridwidth = GridBagConstraints.REMAINDER;
    addLabeledComponentToGBL("Text to use:", textMenu, gbl, gbc, this);

    gbc.weightx = 1;
    gbc.gridwidth = 1;
    gbc.fill = GridBagConstraints.HORIZONTAL;
    gbc.anchor = GridBagConstraints.WEST;
    addLabeledComponentToGBL("LCD contrast: ", contrastSlider, gbl, gbc, this);

    gbc.gridwidth = 1;
    gbc.fill = GridBagConstraints.NONE;
    addLabeledComponentToGBL("Antialiasing: ", antiAliasMenu, gbl, gbc, this);

    gbc.anchor = GridBagConstraints.EAST;
    gbc.gridwidth = GridBagConstraints.REMAINDER;
    addLabeledComponentToGBL("Fractional metrics: ", fracMetricsMenu, gbl, gbc, this);

    gbc.weightx = 1;
    gbc.weighty = 1;
    gbc.anchor = GridBagConstraints.WEST;
    gbc.insets = new Insets(2002);
    gbc.fill = GridBagConstraints.BOTH;
    gbl.setConstraints(fp, gbc);
    this.add(fp);

    gbc.weighty = 0;
    gbc.insets = new Insets(0200);
    gbl.setConstraints(statusBar, gbc);
    this.add(statusBar);
  }

  // / Adds a component to a container with a label to its left in GridBagLayout
  private void addLabeledComponentToGBL(String name, JComponent c, GridBagLayout gbl,
      GridBagConstraints gbc, Container target) {
    LabelV2 l = new LabelV2(name);
    GridBagConstraints gbcLabel = (GridBagConstraintsgbc.clone();
    gbcLabel.insets = new Insets(2220);
    gbcLabel.gridwidth = 1;
    gbcLabel.weightx = 0;

    if (c == null)
      c = new JLabel("");

    gbl.setConstraints(l, gbcLabel);
    target.add(l);
    gbl.setConstraints(c, gbc);
    target.add(c);
  }

  // / Sets up menu entries
  private void setupMenu(boolean isApplet) {
    JMenu fileMenu = new JMenu("File");
    JMenu optionMenu = new JMenu("Option");

    fileMenu.add(new MenuItemV2("Save Selected Options..."this));
    fileMenu.add(new MenuItemV2("Load Options..."this));
    fileMenu.addSeparator();
    fileMenu.add(new MenuItemV2("Save as PNG..."this));
    fileMenu.add(new MenuItemV2("Load PNG File to Compare..."this));
    fileMenu.add(new MenuItemV2("Page Setup..."this));
    fileMenu.add(new MenuItemV2("Print..."this));
    fileMenu.addSeparator();
    if (!isApplet)
      fileMenu.add(new MenuItemV2("Exit"this));
    else
      fileMenu.add(new MenuItemV2("Close"this));

    displayGridCBMI = new CheckboxMenuItemV2("Display Grid", true, this);
    force16ColsCBMI = new CheckboxMenuItemV2("Force 16 Columns", false, this);
    showFontInfoCBMI = new CheckboxMenuItemV2("Display Font Info", false, this);
    optionMenu.add(displayGridCBMI);
    optionMenu.add(force16ColsCBMI);
    optionMenu.add(showFontInfoCBMI);

    JMenuBar mb = parent.getJMenuBar();
    if (mb == null)
      mb = new JMenuBar();
    mb.add(fileMenu);
    mb.add(optionMenu);

    parent.setJMenuBar(mb);

    String fontList[] = GraphicsEnvironment.getLocalGraphicsEnvironment()
        .getAvailableFontFamilyNames();

    for (int i = 0; i < fontList.length; i++)
      fontMenu.addItem(fontList[i]);
    fontMenu.setSelectedItem("Dialog");

    styleMenu.addItem("Plain");
    styleMenu.addItem("Bold");
    styleMenu.addItem("Italic");
    styleMenu.addItem("Bold Italic");

    transformMenu.addItem("None");
    transformMenu.addItem("Scale");
    transformMenu.addItem("Shear");
    transformMenu.addItem("Rotate");

    transformMenuG2.addItem("None");
    transformMenuG2.addItem("Scale");
    transformMenuG2.addItem("Shear");
    transformMenuG2.addItem("Rotate");

    methodsMenu.addItem("drawString");
    methodsMenu.addItem("drawChars");
    methodsMenu.addItem("drawBytes");
    methodsMenu.addItem("drawGlyphVector");
    methodsMenu.addItem("TextLayout.draw");
    methodsMenu.addItem("GlyphVector.getOutline + draw");
    methodsMenu.addItem("TextLayout.getOutline + draw");

    textMenu.addItem("Unicode Range");
    textMenu.addItem("All Glyphs");
    textMenu.addItem("User Text");
    textMenu.addItem("Text File");
    textMenu.addActionListener(this)// listener added later so unneeded events
                                      // not thrown
  }

  // / Sets up the all dialogs used in Font2DTest...
  private void setupDialog(boolean isApplet) {
    if (!isApplet)
      filePromptDialog = new JFileChooser();
    else
      filePromptDialog = null;

    // / Prepare user text dialog...
    userTextDialog = new JDialog(parent, "User Text"false);
    JPanel dialogTopPanel = new JPanel();
    JPanel dialogBottomPanel = new JPanel();
    LabelV2 message1 = new LabelV2("Enter text below and then press update");
    LabelV2 message2 = new LabelV2("(Unicode char can be denoted by \\uXXXX)");
    LabelV2 message3 = new LabelV2("(Supplementary chars can be denoted by \\UXXXXXX)");
    userTextArea = new JTextArea("Java2D!");
    ButtonV2 bUpdate = new ButtonV2("Update"this);
    userTextArea.setFont(new Font("dialog", Font.PLAIN, 12));
    dialogTopPanel.setLayout(new GridLayout(31));
    dialogTopPanel.add(message1);
    dialogTopPanel.add(message2);
    dialogTopPanel.add(message3);
    dialogBottomPanel.add(bUpdate);
    // ABP
    JScrollPane userTextAreaSP = new JScrollPane(userTextArea);
    userTextAreaSP.setPreferredSize(new Dimension(300100));

    userTextDialog.getContentPane().setLayout(new BorderLayout());
    userTextDialog.getContentPane().add("North", dialogTopPanel);
    userTextDialog.getContentPane().add("Center", userTextAreaSP);
    userTextDialog.getContentPane().add("South", dialogBottomPanel);
    userTextDialog.pack();
    userTextDialog.addWindowListener(new WindowAdapter() {
      public void windowClosing(WindowEvent e) {
        userTextDialog.hide();
      }
    });

    // / Prepare printing dialog...
    printCBGroup = new ButtonGroup();
    printModeCBs[fp.ONE_PAGEnew JRadioButton(
        "Print one page from currently displayed character/line"true);
    printModeCBs[fp.CUR_RANGEnew JRadioButton(
        "Print all characters in currently selected range"false);
    printModeCBs[fp.ALL_TEXTnew JRadioButton("Print all lines of text"false);
    LabelV2 l = new LabelV2(
        "Note: Page range in native \"Print\" dialog will not affect the result");
    JPanel buttonPanel = new JPanel();
    printModeCBs[fp.ALL_TEXT].setEnabled(false);
    buttonPanel.add(new ButtonV2("Print"this));
    buttonPanel.add(new ButtonV2("Cancel"this));

    printDialog = new JDialog(parent, "Print..."true);
    printDialog.setResizable(false);
    printDialog.addWindowListener(new WindowAdapter() {
      public void windowClosing(WindowEvent e) {
        printDialog.hide();
      }
    });
    printDialog.getContentPane().setLayout(new GridLayout(printModeCBs.length + 21));
    printDialog.getContentPane().add(l);
    for (int i = 0; i < printModeCBs.length; i++) {
      printCBGroup.add(printModeCBs[i]);
      printDialog.getContentPane().add(printModeCBs[i]);
    }
    printDialog.getContentPane().add(buttonPanel);
    printDialog.pack();

    // / Prepare font information dialog...
    fontInfoDialog = new JDialog(parent, "Font info"false);
    fontInfoDialog.setResizable(false);
    fontInfoDialog.addWindowListener(new WindowAdapter() {
      public void windowClosing(WindowEvent e) {
        fontInfoDialog.hide();
        showFontInfoCBMI.setState(false);
      }
    });
    JPanel fontInfoPanel = new JPanel();
    fontInfoPanel.setLayout(new GridLayout(fontInfos.length, 1));
    for (int i = 0; i < fontInfos.length; i++) {
      fontInfos[inew LabelV2("");
      fontInfoPanel.add(fontInfos[i]);
    }
    fontInfoDialog.getContentPane().add(fontInfoPanel);

    // / Move the location of the dialog...
    userTextDialog.setLocation(200300);
    fontInfoDialog.setLocation(0400);
  }

  // / RangeMenu object signals using this function
  // / when Unicode range has been changed and text needs to be redrawn
  public void fireRangeChanged() {
    int range[] = rm.getSelectedRange();
    fp.setTextToDraw(fp.RANGE_TEXT, range, null, null);
    if (canDisplayCheck) {
      setupFontList(range[0], range[1]);
    }
    if (showFontInfoCBMI.getState())
      fireUpdateFontInfo();
  }

  // / Changes the message on the status bar
  public void fireChangeStatus(String message, boolean error) {
    // / If this is not ran as an applet, use own status bar,
    // / Otherwise, use the appletviewer/browser's status bar
    statusBar.setText(message);
    if (error)
      fp.showingError = true;
    else
      fp.showingError = false;
  }

  // / Updates the information about the selected font
  public void fireUpdateFontInfo() {
    if (showFontInfoCBMI.getState()) {
      String infos[] = fp.getFontInfo();
      for (int i = 0; i < fontInfos.length; i++)
        fontInfos[i].setText(infos[i]);
      fontInfoDialog.pack();
    }
  }

  private void setupFontList(int rangeStart, int rangeEnd) {

    int listCount = fontMenu.getItemCount();
    int size = 16;

    try {
      size = Float.valueOf(sizeField.getText()).intValue();
    catch (Exception e) {
      System.out.println("Invalid font size in the size textField. Using default value of 16");
    }

    int style = fontStyles[styleMenu.getSelectedIndex()];
    Font f;
    for (int i = 0; i < listCount; i++) {
      String fontName = (StringfontMenu.getItemAt(i);
      f = new Font(fontName, style, size);
      if ((rm.getSelectedIndex() != RangeMenu.SURROGATES_AREA_INDEX)
          && canDisplayRange(f, rangeStart, rangeEnd)) {
        fontMenu.setBit(i, true);
      else {
        fontMenu.setBit(i, false);
      }
    }

    fontMenu.repaint();
  }

  protected boolean canDisplayRange(Font font, int rangeStart, int rangeEnd) {
    for (int i = rangeStart; i < rangeEnd; i++) {
      if (font.canDisplay(i)) {
        return true;
      }
    }
    return false;
  }

  // / Displays a file load/save dialog and returns the specified file
  private String promptFile(boolean isSave, String initFileName) {
    int retVal;
    String str;

    // / ABP
    if (filePromptDialog == null)
      return null;

    if (isSave) {
      filePromptDialog.setDialogType(JFileChooser.SAVE_DIALOG);
      filePromptDialog.setDialogTitle("Save...");
      str = "Save";

    else {
      filePromptDialog.setDialogType(JFileChooser.OPEN_DIALOG);
      filePromptDialog.setDialogTitle("Load...");
      str = "Load";
    }

    if (initFileName != null)
      filePromptDialog.setSelectedFile(new File(initFileName));
    retVal = filePromptDialog.showDialog(this, str);

    if (retVal == JFileChooser.APPROVE_OPTION) {
      File file = filePromptDialog.getSelectedFile();
      String fileName = file.getAbsolutePath();
      if (fileName != null) {
        return fileName;
      }
    }

    return null;
  }

  // / Converts user text into arrays of String, delimited at newline character
  // / Also replaces any valid escape sequence with appropriate unicode
  // character
  // / Support \\UXXXXXX notation for surrogates
  private String[] parseUserText(String orig) {
    int length = orig.length();
    StringTokenizer perLine = new StringTokenizer(orig, "\n");
    String textLines[] new String[perLine.countTokens()];
    int lineNumber = 0;

    while (perLine.hasMoreElements()) {
      StringBuffer converted = new StringBuffer();
      String oneLine = perLine.nextToken();
      int lineLength = oneLine.length();
      int prevEscapeEnd = 0;
      int nextEscape = -1;
      do {
        int nextBMPEscape = oneLine.indexOf("\\u", prevEscapeEnd);
        int nextSupEscape = oneLine.indexOf("\\U", prevEscapeEnd);
        nextEscape = (nextBMPEscape < 0((nextSupEscape < 0? -: nextSupEscape)
            ((nextSupEscape < 0? nextBMPEscape : Math.min(nextBMPEscape, nextSupEscape));

        if (nextEscape != -1) {
          if (prevEscapeEnd < nextEscape)
            converted.append(oneLine.substring(prevEscapeEnd, nextEscape));

          prevEscapeEnd = nextEscape + (nextEscape == nextBMPEscape ? 8);
          try {
            String hex = oneLine.substring(nextEscape + 2, prevEscapeEnd);
            if (nextEscape == nextBMPEscape) {
              converted.append((charInteger.parseInt(hex, 16));
            else {
              converted.append(new String(Character.toChars(Integer.parseInt(hex, 16))));
            }
          catch (Exception e) {
            int copyLimit = Math.min(lineLength, prevEscapeEnd);
            converted.append(oneLine.substring(nextEscape, copyLimit));
          }
        }
      while (nextEscape != -1);
      if (prevEscapeEnd < lineLength)
        converted.append(oneLine.substring(prevEscapeEnd, lineLength));
      textLines[lineNumber++= converted.toString();
    }
    return textLines;
  }

  // / Reads the text from specified file, detecting UTF-16 encoding
  // / Then breaks the text into String array, delimited at every line break
  private void readTextFile(String fileName) {
    try {
      String fileText, textLines[];
      BufferedInputStream bis = new BufferedInputStream(new FileInputStream(fileName));
      int numBytes = bis.available();
      if (numBytes == 0) {
        throw new Exception("Text file " + fileName + " is empty");
      }
      byte byteData[] new byte[numBytes];
      bis.read(byteData, 0, numBytes);
      bis.close();

      // / If byte mark is found, then use UTF-16 encoding to convert bytes...
      if (numBytes >= 2
          && ((byteData[0== (byte0xFF && byteData[1== (byte0xFE|| (byteData[0== (byte0xFE && byteData[1== (byte0xFF)))
        fileText = new String(byteData, "UTF-16");
      // / Otherwise, use system default encoding
      else
        fileText = new String(byteData);

      int length = fileText.length();
      StringTokenizer perLine = new StringTokenizer(fileText, "\n");
      // / Determine "Return Char" used in this file
      // / This simply finds first occurrence of CR, CR+LF or LF...
      for (int i = 0; i < length; i++) {
        char iTh = fileText.charAt(i);
        if (iTh == '\r') {
          if (i < length - && fileText.charAt(i + 1== '\n')
            perLine = new StringTokenizer(fileText, "\r\n");
          else
            perLine = new StringTokenizer(fileText, "\r");
          break;
        else if (iTh == '\n')
          // / Use the one already created
          break;
      }
      int lineNumber = 0, numLines = perLine.countTokens();
      textLines = new String[numLines];

      while (perLine.hasMoreElements()) {
        String oneLine = perLine.nextToken();
        if (oneLine == null)
          // / To make LineBreakMeasurer to return a valid TextLayout
          // / on an empty line, simply feed it a space char...
          oneLine = " ";
        textLines[lineNumber++= oneLine;
      }
      fp.setTextToDraw(fp.FILE_TEXT, null, null, textLines);
      rm.setEnabled(false);
      methodsMenu.setEnabled(false);
    catch (Exception ex) {
      fireChangeStatus("ERROR: Failed to Read Text File; See Stack Trace"true);
      ex.printStackTrace();
    }
  }

  // / Returns a String storing current configuration
  private void writeCurrentOptions(String fileName) {
    try {
      String curOptions = fp.getCurrentOptions();
      BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(fileName));
      // / Prepend title and the option that is only obtainable here
      int range[] = rm.getSelectedRange();
      String completeOptions = ("Font2DTest Option File\n" + displayGridCBMI.getState() "\n"
          + force16ColsCBMI.getState() "\n" + showFontInfoCBMI.getState() "\n"
          + rm.getSelectedItem() "\n" + range[0"\n" + range[1"\n" + curOptions + tFileName);
      byte toBeWritten[] = completeOptions.getBytes("UTF-16");
      bos.write(toBeWritten, 0, toBeWritten.length);
      bos.close();
    catch (Exception ex) {
      fireChangeStatus("ERROR: Failed to Save Options File; See Stack Trace"true);
      ex.printStackTrace();
    }
  }

  // / Updates GUI visibility/status after some parameters have changed
  private void updateGUI() {
    int selectedText = textMenu.getSelectedIndex();

    // / Set the visibility of User Text dialog
    if (selectedText == fp.USER_TEXT)
      userTextDialog.show();
    else
      userTextDialog.hide();
    // / Change the visibility/status/availability of Print JDialog buttons
    printModeCBs[fp.ONE_PAGE].setSelected(true);
    if (selectedText == fp.FILE_TEXT || selectedText == fp.USER_TEXT) {
      // / ABP
      // / update methodsMenu to show that TextLayout.draw is being used
      // / when we are in FILE_TEXT mode
      if (selectedText == fp.FILE_TEXT)
        methodsMenu.setSelectedItem("TextLayout.draw");
      methodsMenu.setEnabled(selectedText == fp.USER_TEXT);
      printModeCBs[fp.CUR_RANGE].setEnabled(false);
      printModeCBs[fp.ALL_TEXT].setEnabled(true);
    else {
      // / ABP
      // / update methodsMenu to show that drawGlyph is being used
      // / when we are in ALL_GLYPHS mode
      if (selectedText == fp.ALL_GLYPHS)
        methodsMenu.setSelectedItem("drawGlyphVector");
      methodsMenu.setEnabled(selectedText == fp.RANGE_TEXT);
      printModeCBs[fp.CUR_RANGE].setEnabled(true);
      printModeCBs[fp.ALL_TEXT].setEnabled(false);
    }
    // / Modify RangeMenu and fontInfo label availabilty
    if (selectedText == fp.RANGE_TEXT) {
      fontInfos[1].setVisible(true);
      rm.setEnabled(true);
    else {
      fontInfos[1].setVisible(false);
      rm.setEnabled(false);
    }
  }

  // / Loads saved options and applies them
  private void loadOptions(String fileName) {
    try {
      BufferedInputStream bis = new BufferedInputStream(new FileInputStream(fileName));
      int numBytes = bis.available();
      byte byteData[] new byte[numBytes];
      bis.read(byteData, 0, numBytes);
      bis.close();
      if (numBytes < || (byteData[0!= (byte0xFE || byteData[1!= (byte0xFF))
        throw new Exception("Not a Font2DTest options file");

      String options = new String(byteData, "UTF-16");
      StringTokenizer perLine = new StringTokenizer(options, "\n");
      String title = perLine.nextToken();
      if (!title.equals("Font2DTest Option File"))
        throw new Exception("Not a Font2DTest options file");

      // / Parse all options
      boolean displayGridOpt = Boolean.parseBoolean(perLine.nextToken());
      boolean force16ColsOpt = Boolean.parseBoolean(perLine.nextToken());
      boolean showFontInfoOpt = Boolean.parseBoolean(perLine.nextToken());
      String rangeNameOpt = perLine.nextToken();
      int rangeStartOpt = Integer.parseInt(perLine.nextToken());
      int rangeEndOpt = Integer.parseInt(perLine.nextToken());
      String fontNameOpt = perLine.nextToken();
      float fontSizeOpt = Float.parseFloat(perLine.nextToken());
      int fontStyleOpt = Integer.parseInt(perLine.nextToken());
      int fontTransformOpt = Integer.parseInt(perLine.nextToken());
      int g2TransformOpt = Integer.parseInt(perLine.nextToken());
      int textToUseOpt = Integer.parseInt(perLine.nextToken());
      int drawMethodOpt = Integer.parseInt(perLine.nextToken());
      int antialiasOpt = Integer.parseInt(perLine.nextToken());
      int fractionalOpt = Integer.parseInt(perLine.nextToken());
      int lcdContrast = Integer.parseInt(perLine.nextToken());
      String userTextOpt[] "Java2D!" }, dialogEntry = "Java2D!";
      if (textToUseOpt == fp.USER_TEXT) {
        int numLines = perLine.countTokens(), lineNumber = 0;
        if (numLines != 0) {
          userTextOpt = new String[numLines];
          dialogEntry = "";
          for (; perLine.hasMoreElements(); lineNumber++) {
            userTextOpt[lineNumber= perLine.nextToken();
            dialogEntry += userTextOpt[lineNumber"\n";
          }
        }
      }

      // / Reset GUIs
      displayGridCBMI.setState(displayGridOpt);
      force16ColsCBMI.setState(force16ColsOpt);
      showFontInfoCBMI.setState(showFontInfoOpt);
      rm.setSelectedRange(rangeNameOpt, rangeStartOpt, rangeEndOpt);
      fontMenu.setSelectedItem(fontNameOpt);
      sizeField.setText(String.valueOf(fontSizeOpt));
      styleMenu.setSelectedIndex(fontStyleOpt);
      transformMenu.setSelectedIndex(fontTransformOpt);
      transformMenuG2.setSelectedIndex(g2TransformOpt);
      textMenu.setSelectedIndex(textToUseOpt);
      methodsMenu.setSelectedIndex(drawMethodOpt);
      antiAliasMenu.setSelectedIndex(antialiasOpt);
      fracMetricsMenu.setSelectedIndex(fractionalOpt);
      contrastSlider.setValue(lcdContrast);

      userTextArea.setText(dialogEntry);
      updateGUI();

      if (textToUseOpt == fp.FILE_TEXT) {
        tFileName = perLine.nextToken();
        readTextFile(tFileName);
      }

      // / Reset option variables and repaint
      fp.loadOptions(displayGridOpt, force16ColsOpt, rangeStartOpt, rangeEndOpt, fontNameOpt,
          fontSizeOpt, fontStyleOpt, fontTransformOpt, g2TransformOpt, textToUseOpt, drawMethodOpt,
          antialiasOpt, fractionalOpt, lcdContrast, userTextOpt);
      if (showFontInfoOpt) {
        fireUpdateFontInfo();
        fontInfoDialog.show();
      else
        fontInfoDialog.hide();
    catch (Exception ex) {
      fireChangeStatus("ERROR: Failed to Load Options File; See Stack Trace"true);
      ex.printStackTrace();
    }
  }

  // / Loads a previously saved image
  private void loadComparisonPNG(String fileName) {
    try {
      BufferedImage image = javax.imageio.ImageIO.read(new File(fileName));
      JFrame f = new JFrame("Comparison PNG");
      ImagePanel ip = new ImagePanel(image);
      f.setResizable(false);
      f.getContentPane().add(ip);
      f.addWindowListener(new WindowAdapter() {
        public void windowClosing(WindowEvent e) {
          ((JFramee.getSource()).dispose();
        }
      });
      f.pack();
      f.show();
    catch (Exception ex) {
      fireChangeStatus("ERROR: Failed to Load PNG File; See Stack Trace"true);
      ex.printStackTrace();
    }
  }

  // / Interface functions...

  // / ActionListener interface function
  // / Responds to JMenuItem, JTextField and JButton actions
  public void actionPerformed(ActionEvent e) {
    Object source = e.getSource();

    if (source instanceof JMenuItem) {
      JMenuItem mi = (JMenuItemsource;
      String itemName = mi.getText();

      if (itemName.equals("Save Selected Options...")) {
        String fileName = promptFile(true, "options.txt");
        if (fileName != null)
          writeCurrentOptions(fileName);
      else if (itemName.equals("Load Options...")) {
        String fileName = promptFile(false, "options.txt");
        if (fileName != null)
          loadOptions(fileName);
      else if (itemName.equals("Save as PNG...")) {
        String fileName = promptFile(true, fontMenu.getSelectedItem() ".png");
        if (fileName != null)
          fp.doSavePNG(fileName);
      else if (itemName.equals("Load PNG File to Compare...")) {
        String fileName = promptFile(false, null);
        if (fileName != null)
          loadComparisonPNG(fileName);
      else if (itemName.equals("Page Setup..."))
        fp.doPageSetup();
      else if (itemName.equals("Print..."))
        printDialog.show();
      else if (itemName.equals("Close"))
        parent.dispose();
      else if (itemName.equals("Exit"))
        System.exit(0);
    }

    else if (source instanceof JTextField) {
      JTextField tf = (JTextFieldsource;
      float sz = 12f;
      try {
        sz = Float.parseFloat(sizeField.getText());
        if (sz < 1f || sz > 120f) {
          sz = 12f;
          sizeField.setText("12");
        }
      catch (Exception se) {
        sizeField.setText("12");
      }
      if (tf == sizeField)
        fp.setFontParams(fontMenu.getSelectedItem(), sz, styleMenu.getSelectedIndex(),
            transformMenu.getSelectedIndex());
    }

    else if (source instanceof JButton) {
      String itemName = ((JButtonsource).getText();
      // / Print dialog buttons...
      if (itemName.equals("Print")) {
        for (int i = 0; i < printModeCBs.length; i++)
          if (printModeCBs[i].isSelected()) {
            printDialog.hide();
            fp.doPrint(i);
          }
      else if (itemName.equals("Cancel"))
        printDialog.hide();
      // / Update button from Usert Text JDialog...
      else if (itemName.equals("Update"))
        fp.setTextToDraw(fp.USER_TEXT, null, parseUserText(userTextArea.getText())null);
    else if (source instanceof JComboBox) {
      JComboBox c = (JComboBoxsource;

      // / RangeMenu handles actions by itself and then calls fireRangeChanged,
      // / so it is not listed or handled here
      if (c == fontMenu || c == styleMenu || c == transformMenu) {
        float sz = 12f;
        try {
          sz = Float.parseFloat(sizeField.getText());
          if (sz < 1f || sz > 120f) {
            sz = 12f;
            sizeField.setText("12");
          }
        catch (Exception se) {
          sizeField.setText("12");
        }
        fp.setFontParams(fontMenu.getSelectedItem(), sz, styleMenu.getSelectedIndex(),
            transformMenu.getSelectedIndex());
      else if (c == methodsMenu)
        fp.setDrawMethod(methodsMenu.getSelectedIndex());
      else if (c == textMenu) {

        if (canDisplayCheck) {
          fireRangeChanged();
        }

        int selected = textMenu.getSelectedIndex();

        if (selected == fp.RANGE_TEXT)
          fp.setTextToDraw(fp.RANGE_TEXT, rm.getSelectedRange(), null, null);
        else if (selected == fp.USER_TEXT)
          fp.setTextToDraw(fp.USER_TEXT, null, parseUserText(userTextArea.getText())null);
        else if (selected == fp.FILE_TEXT) {
          String fileName = promptFile(false, null);
          if (fileName != null) {
            tFileName = fileName;
            readTextFile(fileName);
          else {
            // / User cancelled selection; reset to previous choice
            c.setSelectedIndex(currentTextChoice);
            return;
          }
        else if (selected == fp.ALL_GLYPHS)
          fp.setTextToDraw(fp.ALL_GLYPHS, null, null, null);

        updateGUI();
        currentTextChoice = selected;
      else if (c == transformMenuG2) {
        fp.setTransformG2(transformMenuG2.getSelectedIndex());
      else if (c == antiAliasMenu || c == fracMetricsMenu) {
        if (c == antiAliasMenu) {
          boolean enabled = FontPanel.AAValues.isLCDMode(antiAliasMenu.getSelectedItem());
          contrastSlider.setEnabled(enabled);
        }
        fp.setRenderingHints(antiAliasMenu.getSelectedItem(), fracMetricsMenu.getSelectedItem(),
            contrastSlider.getValue());
      }
    }
  }

  public void stateChanged(ChangeEvent e) {
    Object source = e.getSource();
    if (source instanceof JSlider) {
      fp.setRenderingHints(antiAliasMenu.getSelectedItem(), fracMetricsMenu.getSelectedItem(),
          contrastSlider.getValue());
    }
  }

  // / ItemListener interface function
  // / Responds to JCheckBoxMenuItem, JComboBox and JCheckBox actions
  public void itemStateChanged(ItemEvent e) {
    Object source = e.getSource();

    if (source instanceof JCheckBoxMenuItem) {
      JCheckBoxMenuItem cbmi = (JCheckBoxMenuItemsource;
      if (cbmi == displayGridCBMI)
        fp.setGridDisplay(displayGridCBMI.getState());
      else if (cbmi == force16ColsCBMI)
        fp.setForce16Columns(force16ColsCBMI.getState());
      else if (cbmi == showFontInfoCBMI) {
        if (showFontInfoCBMI.getState()) {
          fireUpdateFontInfo();
          fontInfoDialog.show();
        else
          fontInfoDialog.hide();
      }
    }
  }

  private static void printUsage() {
    String usage = "Usage: java -jar Font2DTest.jar [options]\n" "\nwhere options include:\n"
        "    -dcdc | -disablecandisplaycheck disable canDisplay check for font\n"
        "    -?    | -help                   print this help message\n" "\nExample :\n"
        "     To disable canDisplay check on font for ranges\n"
        "     java -jar Font2DTest.jar -dcdc";
    System.out.println(usage);
    System.exit(0);
  }

  // / Main function
  public static void main(String argv[]) {

    if (argv.length > 0) {
      if (argv[0].equalsIgnoreCase("-disablecandisplaycheck"|| argv[0].equalsIgnoreCase("-dcdc")) {
        canDisplayCheck = false;
      else {
        printUsage();
      }
    }

    UIManager.put("swing.boldMetal", Boolean.FALSE);
    final JFrame f = new JFrame("Font2DTest");
    final Font2DTest f2dt = new Font2DTest(f, false);
    f.addWindowListener(new WindowAdapter() {
      public void windowOpening(WindowEvent e) {
        f2dt.repaint();
      }

      public void windowClosing(WindowEvent e) {
        System.exit(0);
      }
    });

    f.getContentPane().add(f2dt);
    f.pack();
    f.show();
  }

  // / Inner class definitions...

  // / Class to display just an image file
  // / Used to show the comparison PNG image
  private final class ImagePanel extends JPanel {
    private final BufferedImage bi;

    public ImagePanel(BufferedImage image) {
      bi = image;
    }

    public Dimension getPreferredSize() {
      return new Dimension(bi.getWidth(), bi.getHeight());
    }

    public void paintComponent(Graphics g) {
      g.drawImage(bi, 00this);
    }
  }

  // / Classes made to avoid repetitive calls... (being lazy)
  private final class ButtonV2 extends JButton {
    public ButtonV2(String name, ActionListener al) {
      super(name);
      this.addActionListener(al);
    }
  }

  private final class ChoiceV2 extends JComboBox {

    private BitSet bitSet = null;

    public ChoiceV2() {
      ;
    }

    public ChoiceV2(ActionListener al) {
      super();
      this.addActionListener(al);
    }

    public ChoiceV2(ActionListener al, boolean fontChoice) {
      this(al);
      if (fontChoice) {
        // Register this component in ToolTipManager
        setToolTipText("");
        bitSet = new BitSet();
        setRenderer(new ChoiceV2Renderer(this));
      }
    }

    public String getToolTipText() {
      int index = this.getSelectedIndex();
      String fontName = (Stringthis.getSelectedItem();
      if (fontName != null && (textMenu.getSelectedIndex() == fp.RANGE_TEXT)) {
        if (getBit(index)) {
          return "Font \"" + fontName + "\" can display some characters in \""
              + rm.getSelectedItem() "\" range";
        else {
          return "Font \"" + fontName + "\" cannot display any characters in \""
              + rm.getSelectedItem() "\" range";
        }
      }
      return super.getToolTipText();
    }

    public void setBit(int bitIndex, boolean value) {
      bitSet.set(bitIndex, value);
    }

    public boolean getBit(int bitIndex) {
      return bitSet.get(bitIndex);
    }
  }

  private final class ChoiceV2Renderer extends DefaultListCellRenderer {

    private ImageIcon yesImage, blankImage;

    private ChoiceV2 choice = null;

    public ChoiceV2Renderer(ChoiceV2 choice) {
      try {
        yesImage = new ImageIcon(getClass().getResource("yes.gif"));
        blankImage = new ImageIcon(getClass().getResource("blank.gif"));
      catch (Exception exception) {
        System.out.println("Exception : " + exception);
      }
      this.choice = choice;
    }

    public Component getListCellRendererComponent(JList list, Object value, int index,
        boolean isSelected, boolean cellHasFocus) {

      if (textMenu.getSelectedIndex() == fp.RANGE_TEXT) {

        super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);

        // For JComboBox if index is -1, its rendering the selected index.
        if (index == -1) {
          index = choice.getSelectedIndex();
        }

        if (choice.getBit(index)) {
          setIcon(yesImage);
        else {
          setIcon(blankImage);
        }

      else {
        super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
        setIcon(blankImage);
      }

      return this;
    }
  }

  private final class LabelV2 extends JLabel {
    public LabelV2(String name) {
      super(name);
    }
  }

  private final class MenuItemV2 extends JMenuItem {
    public MenuItemV2(String name, ActionListener al) {
      super(name);
      this.addActionListener(al);
    }
  }

  private final class CheckboxMenuItemV2 extends JCheckBoxMenuItem {
    public CheckboxMenuItemV2(String name, boolean b, ItemListener il) {
      super(name, b);
      this.addItemListener(il);
    }
  }
}

/*
 * @(#)FontPanel.java 1.20 05/11/17
 
 * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 
 * -Redistribution of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer.
 
 * -Redistribution in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 
 * Neither the name of Sun Microsystems, Inc. or the names of contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 
 * This software is provided "AS IS," without a warranty of any kind. ALL
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
 * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
 * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MIDROSYSTEMS, INC. ("SUN") AND ITS
 * LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A
 * RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
 * IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT
 * OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
 * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
 * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF SUN HAS
 * BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 
 * You acknowledge that this software is not designed, licensed or intended for
 * use in the design, construction, operation or maintenance of any nuclear
 * facility.
 */

/*
 * @(#)FontPanel.java 1.20 05/11/17
 */

/**
 * FontPanel.java
 
 @version
 * @(#)FontPanel.java 1.1 00/08/22
 @author Shinsuke Fukuda
 @author Ankit Patel [Conversion to Swing - 01/07/30]
 */

// / This panel is combination of the text drawing area of Font2DTest
// / and the custom controlled scroll bar
final class FontPanel extends JPanel implements AdjustmentListener {

  // / Drawing Option Constants
  private final String STYLES[] "plain""bold""italic""bold italic" };

  private final int NONE = 0;

  private final int SCALE = 1;

  private final int SHEAR = 2;

  private final int ROTATE = 3;

  private final String TRANSFORMS[] "with no transforms""with scaling""with Shearing",
      "with rotation" };

  private final int DRAW_STRING = 0;

  private final int DRAW_CHARS = 1;

  private final int DRAW_BYTES = 2;

  private final int DRAW_GLYPHV = 3;

  private final int TL_DRAW = 4;

  private final int GV_OUTLINE = 5;

  private final int TL_OUTLINE = 6;

  private final String METHODS[] "drawString""drawChars""drawBytes""drawGlyphVector",
      "TextLayout.draw""GlyphVector.getOutline""TextLayout.getOutline" };

  public final int RANGE_TEXT = 0;

  public final int ALL_GLYPHS = 1;

  public final int USER_TEXT = 2;

  public final int FILE_TEXT = 3;

  private final String MS_OPENING[] " Unicode "" Glyph Code "" lines "" lines " };

  private final String MS_CLOSING[] """"" of User Text ",
      " of LineBreakMeasurer-reformatted Text " };

  // / General Graphics Variable
  private final JScrollBar verticalBar;

  private final FontCanvas fc;

  private boolean updateBackBuffer = true;

  private boolean updateFontMetrics = true;

  private boolean updateFont = true;

  private boolean force16Cols = false;

  public boolean showingError = false;

  private int g2Transform = NONE; // / ABP

  // / Printing constants and variables
  public final int ONE_PAGE = 0;

  public final int CUR_RANGE = 1;

  public final int ALL_TEXT = 2;

  private int printMode = ONE_PAGE;

  private PageFormat page = null;

  private PrinterJob printer = null;

  // / Text drawing variables
  private String fontName = "Dialog";

  private float fontSize = 12;

  private int fontStyle = Font.PLAIN;

  private int fontTransform = NONE;

  private Font testFont = null;

  private Object antiAliasType = VALUE_TEXT_ANTIALIAS_DEFAULT;

  private Object fractionalMetricsType = VALUE_FRACTIONALMETRICS_DEFAULT;

  private Object lcdContrast = getDefaultLCDContrast();

  private int drawMethod = DRAW_STRING;

  private int textToUse = RANGE_TEXT;

  private String userText[] null;

  private String fileText[] null;

  private int drawRange[] 0x00000x007f };

  private String fontInfos[] new String[2];

  private boolean showGrid = true;

  // / Parent Font2DTest panel
  private final Font2DTest f2dt;

  private final JFrame parent;

  public FontPanel(Font2DTest demo, JFrame f) {
    f2dt = demo;
    parent = f;

    verticalBar = new JScrollBar(JScrollBar.VERTICAL);
    fc = new FontCanvas();

    this.setLayout(new BorderLayout());
    this.add("Center", fc);
    this.add("East", verticalBar);

    verticalBar.addAdjustmentListener(this);
    this.addComponentListener(new ComponentAdapter() {
      public void componentResized(ComponentEvent e) {
        updateBackBuffer = true;
        updateFontMetrics = true;
      }
    });

    // / Initialize font and its infos
    testFont = new Font(fontName, fontStyle, (intfontSize);
    if ((float) ((intfontSize!= fontSize) {
      testFont = testFont.deriveFont(fontSize);
    }
    updateFontInfo();
  }

  public Dimension getPreferredSize() {
    return new Dimension(600200);
  }

  // / Functions called by the main programs to set the various parameters

  public void setTransformG2(int transform) {
    g2Transform = transform;
    updateBackBuffer = true;
    updateFontMetrics = true;
    fc.repaint();
  }

  // / convenience fcn to create AffineTransform of appropriate type
  private AffineTransform getAffineTransform(int transform) {
    // / ABP
    AffineTransform at = new AffineTransform();
    switch (transform) {
    case SCALE:
      at.setToScale(1.5f1.5f);
      break;
    case ROTATE:
      at.setToRotation(Math.PI / 6);
      break;
    case SHEAR:
      at.setToShear(0.4f0);
      break;
    case NONE:
      break;
    default:
      // System.err.println( "Illegal G2 Transform Arg: " + transform);
      break;
    }

    return at;
  }

  public void setFontParams(Object obj, float size, int style, int transform) {
    setFontParams((Stringobj, size, style, transform);
  }

  public void setFontParams(String name, float size, int style, int transform) {
    boolean fontModified = false;
    if (!name.equals(fontName|| style != fontStyle)
      fontModified = true;

    fontName = name;
    fontSize = size;
    fontStyle = style;
    fontTransform = transform;

    // / Recreate the font as specified
    testFont = new Font(fontName, fontStyle, (intfontSize);
    if ((float) ((intfontSize!= fontSize) {
      testFont = testFont.deriveFont(fontSize);
    }

    if (fontTransform != NONE) {
      AffineTransform at = getAffineTransform(fontTransform);
      testFont = testFont.deriveFont(at);
    }
    updateBackBuffer = true;
    updateFontMetrics = true;
    fc.repaint();
    if (fontModified) {
      // / Tell main panel to update the font info
      updateFontInfo();
      f2dt.fireUpdateFontInfo();
    }
  }

  public void setRenderingHints(Object aa, Object fm, Object contrast) {
    antiAliasType = ((AAValuesaa).getHint();
    fractionalMetricsType = ((FMValuesfm).getHint();
    lcdContrast = contrast;
    updateBackBuffer = true;
    updateFontMetrics = true;
    fc.repaint();
  }

  public void setDrawMethod(int i) {
    drawMethod = i;
    updateBackBuffer = true;
    fc.repaint();
  }

  public void setTextToDraw(int i, int range[], String textSet[], String fileData[]) {
    textToUse = i;

    if (textToUse == RANGE_TEXT)
      drawRange = range;
    else if (textToUse == ALL_GLYPHS)
      drawMethod = DRAW_GLYPHV;
    else if (textToUse == USER_TEXT)
      userText = textSet;
    else if (textToUse == FILE_TEXT) {
      fileText = fileData;
      drawMethod = TL_DRAW;
    }

    updateBackBuffer = true;
    updateFontMetrics = true;
    fc.repaint();
    updateFontInfo();
  }

  public void setGridDisplay(boolean b) {
    showGrid = b;
    updateBackBuffer = true;
    fc.repaint();
  }

  public void setForce16Columns(boolean b) {
    force16Cols = b;
    updateBackBuffer = true;
    updateFontMetrics = true;
    fc.repaint();
  }

  // / Prints out the text display area
  public void doPrint(int i) {
    if (printer == null) {
      printer = PrinterJob.getPrinterJob();
      page = printer.defaultPage();
    }
    printMode = i;
    printer.setPrintable(fc, page);

    if (printer.printDialog()) {
      try {
        printer.print();
      catch (Exception e) {
        f2dt.fireChangeStatus("ERROR: Printing Failed; See Stack Trace"true);
      }
    }
  }

  // / Displays the page setup dialog and updates PageFormat info
  public void doPageSetup() {
    if (printer == null) {
      printer = PrinterJob.getPrinterJob();
      page = printer.defaultPage();
    }
    page = printer.pageDialog(page);
  }

  // / Obtains the information about selected font
  private void updateFontInfo() {
    int numGlyphs = 0, numCharsInRange = drawRange[1- drawRange[01;
    fontInfos[0"Font Face Name: " + testFont.getFontName();
    fontInfos[1"Glyphs in This Range: ";

    if (textToUse == RANGE_TEXT) {
      for (int i = drawRange[0]; i < drawRange[1]; i++)
        if (testFont.canDisplay(i))
          numGlyphs++;
      fontInfos[1= fontInfos[1+ numGlyphs + " / " + numCharsInRange;
    else
      fontInfos[1null;
  }

  // / Accessor for the font information
  public String[] getFontInfo() {
    return fontInfos;
  }

  // / Collects the currectly set options and returns them as string
  public String getCurrentOptions() {
    // / Create a new String to store the options
    // / The array will contain all 8 setting (font name, size...) and
    // / character range or user text data used (no file text data)
    int userTextSize = 0;
    String options;

    options = (fontName + "\n" + fontSize + "\n" + fontStyle + "\n" + fontTransform + "\n"
        + g2Transform + "\n" + textToUse + "\n" + drawMethod + "\n"
        + AAValues.getHintVal(antiAliasType"\n" + FMValues.getHintVal(fractionalMetricsType)
        "\n" + lcdContrast + "\n");
    if (textToUse == USER_TEXT)
      for (int i = 0; i < userText.length; i++)
        options += (userText[i"\n");

    return options;
  }

  // / Reload all options and refreshes the canvas
  public void loadOptions(boolean grid, boolean force16, int start, int end, String name,
      float size, int style, int transform, int g2transform, int text, int method, int aa, int fm,
      int contrast, String user[]) {
    int range[] start, end };

    // / Since repaint call has a low priority, these functions will finish
    // / before the actual repainting is done
    setGridDisplay(grid);
    setForce16Columns(force16);
    // previous call to readTextFile has already set the text to draw
    if (textToUse != FILE_TEXT) {
      setTextToDraw(text, range, user, null);
    }
    setFontParams(name, size, style, transform);
    setTransformG2(g2transform)// ABP
    setDrawMethod(method);
    setRenderingHints(AAValues.getValue(aa), FMValues.getValue(fm)new Integer(contrast));
  }

  // / Writes the current screen to PNG file
  public void doSavePNG(String fileName) {
    fc.writePNG(fileName);
  }

  // / When scrolled using the scroll bar, update the backbuffer
  public void adjustmentValueChanged(AdjustmentEvent e) {
    updateBackBuffer = true;
    fc.repaint();
  }

  public void paintComponent(Graphics g) {
    // Windows does not repaint correctly, after
    // a zoom. Thus, we need to force the canvas
    // to repaint, but only once. After the first repaint,
    // everything stabilizes. [ABP]
    fc.repaint();
  }

  // / Inner class definition...

  // / Inner panel that holds the actual drawing area and its routines
  private class FontCanvas extends JPanel implements MouseListener, MouseMotionListener, Printable {

    // / Number of characters that will fit across and down this canvas
    private int numCharAcross, numCharDown;

    // / First and last character/line that will be drawn
    // / Limit is the end of range/text where no more draw will be done
    private int drawStart, drawEnd, drawLimit;

    // / FontMetrics variables
    // / Here, gridWidth is equivalent to maxAdvance (slightly bigger though)
    // / and gridHeight is equivalent to lineHeight
    private int maxAscent, maxDescent, gridWidth = 0, gridHeight = 0;

    // / Offset from the top left edge of the canvas where the draw will start
    private int canvasInset_X = 5, canvasInset_Y = 5;

    // / Offscreen buffer of this canvas
    private BufferedImage backBuffer = null;

    // / LineBreak'ed TextLayout vector
    private Vector lineBreakTLs = null;

    // / Whether the current draw command requested is for printing
    private boolean isPrinting = false;

    // / Other printing infos
    private int lastPage, printPageNumber, currentlyShownChar = 0;

    private final int PR_OFFSET = 10;

    private final int PR_TITLE_LINEHEIGHT = 30;

    // / Information about zooming (used with range text draw)
    private final JWindow zoomWindow;

    private BufferedImage zoomImage = null;

    private int mouseOverCharX = -1, mouseOverCharY = -1;

    private int currMouseOverChar = -1, prevZoomChar = -1;

    private float ZOOM = 2.0f;

    private boolean nowZooming = false;

    private boolean firstTime = true;

    // ABP

    // / Status bar message backup
    private String backupStatusString = null;

    // / Error constants
    private final String ERRORS[] {
        "ERROR: drawBytes cannot handle characters beyond 0x00FF. Select different range or draw methods.",
        "ERROR: Cannot fit text with the current font size. Resize the window or use smaller font size.",
        "ERROR: Cannot print with the current font size. Use smaller font size."};

    private final int DRAW_BYTES_ERROR = 0;

    private final int CANT_FIT_DRAW = 1;

    private final int CANT_FIT_PRINT = 2;

    // / Other variables
    private final Cursor blankCursor;

    public FontCanvas() {
      this.addMouseListener(this);
      this.addMouseMotionListener(this);
      this.setForeground(Color.black);
      this.setBackground(Color.white);

      // / Creates an invisble pointer by giving it bogus image
      // / Possibly find a workaround for this...
      Toolkit tk = Toolkit.getDefaultToolkit();
      byte bogus[] { (byte};
      blankCursor = tk.createCustomCursor(tk.createImage(bogus)new Point(00)"");

      zoomWindow = new JWindow(parent) {
        public void paint(Graphics g) {
          g.drawImage(zoomImage, 00, zoomWindow);
        }
      };
      zoomWindow.setCursor(blankCursor);
      zoomWindow.pack();
    }

    public boolean firstTime() {
      return firstTime;
    }

    public void refresh() {
      firstTime = false;
      updateBackBuffer = true;
      repaint();
    }

    // / Sets the font, hints, according to the set parameters
    private void setParams(Graphics2D g2) {
      g2.setFont(testFont);
      g2.setRenderingHint(KEY_TEXT_ANTIALIASING, antiAliasType);
      g2.setRenderingHint(KEY_FRACTIONALMETRICS, fractionalMetricsType);
      g2.setRenderingHint(KEY_TEXT_LCD_CONTRAST, lcdContrast);
      /*
       * I am preserving a somewhat dubious behaviour of this program. Outline
       * text would be drawn anti-aliased by setting the graphics anti-aliasing
       * hint if the text anti-aliasing hint was set. The dubious element here
       * is that people simply using this program may think this is built-in
       * behaviour but its not - at least not when the app explictly draws
       * outline text. This becomes more dubious in cases such as "GASP" where
       * the size at which text is AA'ed is not something you can easily
       * calculate, so mimicing that behaviour isn't going to be easy. So I
       * precisely preserve the behaviour : this is done only if the AA value is
       * "ON". Its not applied in the other cases.
       */
      if (antiAliasType == VALUE_TEXT_ANTIALIAS_ON
          && (drawMethod == TL_OUTLINE || drawMethod == GV_OUTLINE)) {
        g2.setRenderingHint(KEY_ANTIALIASING, VALUE_ANTIALIAS_ON);
      else {
        g2.setRenderingHint(KEY_ANTIALIASING, VALUE_ANTIALIAS_OFF);
      }
    }

    // / Draws the grid (Used for unicode/glyph range drawing)
    private void drawGrid(Graphics2D g2) {
      int totalGridWidth = numCharAcross * gridWidth;
      int totalGridHeight = numCharDown * gridHeight;

      g2.setColor(Color.black);
      for (int i = 0; i < numCharDown + 1; i++)
        g2.drawLine(canvasInset_X, i * gridHeight + canvasInset_Y, canvasInset_X + totalGridWidth,
            i * gridHeight + canvasInset_Y);
      for (int i = 0; i < numCharAcross + 1; i++)
        g2.drawLine(i * gridWidth + canvasInset_X, canvasInset_Y, i * gridWidth + canvasInset_X,
            canvasInset_Y + totalGridHeight);
    }

    // / Draws one character at time onto the canvas according to
    // / the method requested (Used for RANGE_TEXT and ALL_GLYPHS)
    public void modeSpecificDrawChar(Graphics2D g2, int charCode, int baseX, int baseY) {
      GlyphVector gv;
      int oneGlyph[] charCode };
      char charArray[] = Character.toChars(charCode);

      FontRenderContext frc = g2.getFontRenderContext();
      AffineTransform oldTX = g2.getTransform();

      // / Create GlyphVector to measure the exact visual advance
      // / Using that number, adjust the position of the character drawn
      if (textToUse == ALL_GLYPHS)
        gv = testFont.createGlyphVector(frc, oneGlyph);
      else
        gv = testFont.createGlyphVector(frc, charArray);
      Rectangle2D r2d2 = gv.getPixelBounds(frc, 00);
      int shiftedX = baseX;
      // getPixelBounds returns a result in device space.
      // we need to convert back to user space to be able to
      // calculate the shift as baseX is in user space.
      try {
        double pt[] new double[4];
        pt[0= r2d2.getX();
        pt[1= r2d2.getY();
        pt[2= r2d2.getX() + r2d2.getWidth();
        pt[3= r2d2.getY() + r2d2.getHeight();
        oldTX.inverseTransform(pt, 0, pt, 02);
        shiftedX = baseX - (int) (pt[2+ pt[0]);
      catch (NoninvertibleTransformException e) {
      }

      // / ABP - keep track of old tform, restore it later

      g2.translate(shiftedX, baseY);
      g2.transform(getAffineTransform(g2Transform));

      if (textToUse == ALL_GLYPHS)
        g2.drawGlyphVector(gv, 0f0f);
      else {
        if (testFont.canDisplay(charCode))
          g2.setColor(Color.black);
        else {
          g2.setColor(Color.lightGray);
        }

        switch (drawMethod) {
        case DRAW_STRING:
          g2.drawString(new String(charArray)00);
          break;
        case DRAW_CHARS:
          g2.drawChars(charArray, 0100);
          break;
        case DRAW_BYTES:
          if (charCode > 0xff)
            throw new CannotDrawException(DRAW_BYTES_ERROR);
          byte oneByte[] { (bytecharCode };
          g2.drawBytes(oneByte, 0100);
          break;
        case DRAW_GLYPHV:
          g2.drawGlyphVector(gv, 0f0f);
          break;
        case TL_DRAW:
          TextLayout tl = new TextLayout(new String(charArray), testFont, frc);
          tl.draw(g2, 0f0f);
          break;
        case GV_OUTLINE:
          r2d2 = gv.getVisualBounds();
          shiftedX = baseX - (int) (r2d2.getWidth() + r2d2.getX());
          g2.draw(gv.getOutline(0f0f));
          break;
        case TL_OUTLINE:
          r2d2 = gv.getVisualBounds();
          shiftedX = baseX - (int) (r2d2.getWidth() + r2d2.getX());
          TextLayout tlo = new TextLayout(new String(charArray), testFont, g2
              .getFontRenderContext());
          g2.draw(tlo.getOutline(null));
        }
      }

      // / ABP - restore old tform
      g2.setTransform(oldTX);
    }

    // Java2D!\\U01d586\\U01d587\\U01d588

    // / Draws one line of text at given position
    private void modeSpecificDrawLine(Graphics2D g2, String line, int baseX, int baseY) {
      // / ABP - keep track of old tform, restore it later
      AffineTransform oldTx = null;
      oldTx = g2.getTransform();
      g2.translate(baseX, baseY);
      g2.transform(getAffineTransform(g2Transform));

      switch (drawMethod) {
      case DRAW_STRING:
        g2.drawString(line, 00);
        break;
      case DRAW_CHARS:
        g2.drawChars(line.toCharArray()0, line.length()00);
        break;
      case DRAW_BYTES:
        try {
          byte lineBytes[] = line.getBytes("ISO-8859-1");
          g2.drawBytes(lineBytes, 0, lineBytes.length, 00);
        catch (Exception e) {
          e.printStackTrace();
        }
        break;
      case DRAW_GLYPHV:
        GlyphVector gv = testFont.createGlyphVector(g2.getFontRenderContext(), line);
        g2.drawGlyphVector(gv, (float0(float0);
        break;
      case TL_DRAW:
        TextLayout tl = new TextLayout(line, testFont, g2.getFontRenderContext());
        tl.draw(g2, (float0(float0);
        break;
      case GV_OUTLINE:
        GlyphVector gvo = testFont.createGlyphVector(g2.getFontRenderContext(), line);
        g2.draw(gvo.getOutline((float0(float0));
        break;
      case TL_OUTLINE:
        TextLayout tlo = new TextLayout(line, testFont, g2.getFontRenderContext());
        AffineTransform at = new AffineTransform();
        g2.draw(tlo.getOutline(at));
      }

      // / ABP - restore old tform
      g2.setTransform(oldTx);

    }

    // / Draws one line of text at given position
    private void tlDrawLine(Graphics2D g2, TextLayout tl, float baseX, float baseY) {
      // / ABP - keep track of old tform, restore it later
      AffineTransform oldTx = null;
      oldTx = g2.getTransform();
      g2.translate(baseX, baseY);
      g2.transform(getAffineTransform(g2Transform));

      tl.draw(g2, (float0(float0);

      // / ABP - restore old tform
      g2.setTransform(oldTx);

    }

    // / If textToUse is set to range drawing, then convert
    // / int to hex string and prepends 0s to make it length 4
    // / Otherwise line number was fed; simply return number + 1 converted to
    // String
    // / (This is because first line is 1, not 0)
    private String modeSpecificNumStr(int i) {
      if (textToUse == USER_TEXT || textToUse == FILE_TEXT)
        return String.valueOf(i + 1);

      StringBuffer s = new StringBuffer(Integer.toHexString(i));
      while (s.length() 4)
        s.insert(0"0");
      return s.toString().toUpperCase();
    }

    // / Resets the scrollbar to display correct range of text currently on
    // screen
    // / (This scrollbar is not part of a "ScrollPane". It merely simulates its
    // effect by
    // / indicating the necessary area to be drawn within the panel.
    // / By doing this, it prevents creating gigantic panel when large text
    // range,
    // / i.e. CJK Ideographs, is requested)
    private void resetScrollbar(int oldValue) {
      int totalNumRows = 1, numCharToDisplay;
      if (textToUse == RANGE_TEXT || textToUse == ALL_GLYPHS) {
        if (textToUse == RANGE_TEXT)
          numCharToDisplay = drawRange[1- drawRange[0];
        else
          // / textToUse == ALL_GLYPHS
          numCharToDisplay = testFont.getNumGlyphs();

        totalNumRows = numCharToDisplay / numCharAcross;
        if (numCharToDisplay % numCharAcross != 0)
          totalNumRows++;
        if (oldValue / numCharAcross > totalNumRows)
          oldValue = 0;

        verticalBar.setValues(oldValue / numCharAcross, numCharDown, 0, totalNumRows);
      else {
        if (textToUse == USER_TEXT)
          totalNumRows = userText.length;
        else
          // / textToUse == FILE_TEXT;
          totalNumRows = lineBreakTLs.size();
        verticalBar.setValues(oldValue, numCharDown, 0, totalNumRows);
      }
      if (totalNumRows <= numCharDown && drawStart == 0) {
        verticalBar.setEnabled(false);
      else {
        verticalBar.setEnabled(true);
      }
    }

    // / Calculates the font's metrics that will be used for draw
    private void calcFontMetrics(Graphics2D g2d, int w, int h) {
      FontMetrics fm;
      Graphics2D g2 = (Graphics2Dg2d.create();

      // / ABP
      if (g2Transform != NONE && textToUse != FILE_TEXT) {
        g2.setFont(g2.getFont().deriveFont(getAffineTransform(g2Transform)));
        fm = g2.getFontMetrics();
      else {
        fm = g2.getFontMetrics();
      }

      maxAscent = fm.getMaxAscent();
      maxDescent = fm.getMaxDescent();
      if (maxAscent == 0)
        maxAscent = 10;
      if (maxDescent == 0)
        maxDescent = 5;
      if (textToUse == RANGE_TEXT || textToUse == ALL_GLYPHS) {
        // / Give slight extra room for each character
        maxAscent += 3;
        maxDescent += 3;
        gridWidth = fm.getMaxAdvance() 6;
        gridHeight = maxAscent + maxDescent;
        if (force16Cols)
          numCharAcross = 16;
        else
          numCharAcross = (w - 10/ gridWidth;
        numCharDown = (h - 10/ gridHeight;

        canvasInset_X = (w - numCharAcross * gridWidth2;
        canvasInset_Y = (h - numCharDown * gridHeight2;
        if (numCharDown == || numCharAcross == 0)
          throw new CannotDrawException(isPrinting ? CANT_FIT_PRINT : CANT_FIT_DRAW);

        if (!isPrinting)
          resetScrollbar(verticalBar.getValue() * numCharAcross);
      else {
        maxDescent += fm.getLeading();
        canvasInset_X = 5;
        canvasInset_Y = 5;
        // / gridWidth and numCharAcross will not be used in this mode...
        gridHeight = maxAscent + maxDescent;
        numCharDown = (h - canvasInset_Y * 2/ gridHeight;

        if (numCharDown == 0)
          throw new CannotDrawException(isPrinting ? CANT_FIT_PRINT : CANT_FIT_DRAW);
        // / If this is text loaded from file, prepares the LineBreak'ed
        // / text layout at this point
        if (textToUse == FILE_TEXT) {
          if (!isPrinting)
            f2dt.fireChangeStatus("LineBreaking Text... Please Wait"false);
          lineBreakTLs = new Vector();
          for (int i = 0; i < fileText.length; i++) {
            AttributedString as = new AttributedString(fileText[i], g2.getFont().getAttributes());

            LineBreakMeasurer lbm = new LineBreakMeasurer(as.getIterator(), g2
                .getFontRenderContext());

            while (lbm.getPosition() < fileText[i].length())
              lineBreakTLs.add(lbm.nextLayout((floatw));

          }
        }
        if (!isPrinting)
          resetScrollbar(verticalBar.getValue());
      }
    }

    // / Calculates the amount of text that will be displayed on screen
    private void calcTextRange() {
      String displaying = null;

      if (textToUse == RANGE_TEXT || textToUse == ALL_GLYPHS) {
        if (isPrinting)
          if (printMode == ONE_PAGE)
            drawStart = currentlyShownChar;
          else
            // / printMode == CUR_RANGE
            drawStart = numCharAcross * numCharDown * printPageNumber;
        else
          drawStart = verticalBar.getValue() * numCharAcross;
        if (textToUse == RANGE_TEXT) {
          drawStart += drawRange[0];
          drawLimit = drawRange[1];
        else
          drawLimit = testFont.getNumGlyphs();
        drawEnd = drawStart + numCharAcross * numCharDown - 1;

        if (drawEnd >= drawLimit)
          drawEnd = drawLimit;
      else {
        if (isPrinting)
          if (printMode == ONE_PAGE)
            drawStart = currentlyShownChar;
          else
            // / printMode == ALL_TEXT
            drawStart = numCharDown * printPageNumber;
        else {
          drawStart = verticalBar.getValue();
        }

        drawEnd = drawStart + numCharDown - 1;

        if (textToUse == USER_TEXT)
          drawLimit = userText.length - 1;
        else
          drawLimit = lineBreakTLs.size() 1;

        if (drawEnd >= drawLimit)
          drawEnd = drawLimit;
      }

      // ABP
      if (drawStart > drawEnd) {
        drawStart = 0;
        verticalBar.setValue(drawStart);
      }

      // / Change the status bar if not printing...
      if (!isPrinting) {
        backupStatusString = ("Displaying" + MS_OPENING[textToUse+ modeSpecificNumStr(drawStart)
            " to " + modeSpecificNumStr(drawEnd+ MS_CLOSING[textToUse]);
        f2dt.fireChangeStatus(backupStatusString, false);
      }
    }

    // / Draws text according to the parameters set by Font2DTest GUI
    private void drawText(Graphics g, int w, int h) {
      Graphics2D g2;

      // / Create back buffer when not printing, and its Graphics2D
      // / Then set drawing parameters for that Graphics2D object
      if (isPrinting)
        g2 = (Graphics2Dg;
      else {
        backBuffer = (BufferedImagethis.createImage(w, h);
        g2 = backBuffer.createGraphics();
        g2.setColor(Color.white);
        g2.fillRect(00, w, h);
        g2.setColor(Color.black);
      }

      // / sets font, RenderingHints.
      setParams(g2);

      // / If flag is set, recalculate fontMetrics and reset the scrollbar
      if (updateFontMetrics || isPrinting) {
        // / NOTE: re-calculates in case G2 transform
        // / is something other than NONE
        calcFontMetrics(g2, w, h);
        updateFontMetrics = false;
      }
      // / Calculate the amount of text that can be drawn...
      calcTextRange();

      // / Draw according to the set "Text to Use" mode
      if (textToUse == RANGE_TEXT || textToUse == ALL_GLYPHS) {
        int charToDraw = drawStart;
        if (showGrid)
          drawGrid(g2);
        if (!isPrinting)
          g.drawImage(backBuffer, 00this);

        for (int i = 0; i < numCharDown && charToDraw <= drawEnd; i++) {
          for (int j = 0; j < numCharAcross && charToDraw <= drawEnd; j++, charToDraw++) {
            int gridLocX = j * gridWidth + canvasInset_X;
            int gridLocY = i * gridHeight + canvasInset_Y;

            modeSpecificDrawChar(g2, charToDraw, gridLocX + gridWidth / 2, gridLocY + maxAscent);
            // if ( !isPrinting ) {
            // g.setClip( gridLocX, gridLocY, gridWidth + 1, gridHeight + 1 );
            // g.drawImage( backBuffer, 0, 0, this );
            // }

          }
        }
      else if (textToUse == USER_TEXT) {
        g2.drawRect(00, w - 1, h - 1);
        if (!isPrinting)
          g.drawImage(backBuffer, 00this);

        for (int i = drawStart; i <= drawEnd; i++) {
          int lineStartX = canvasInset_Y;
          int lineStartY = (i - drawStart* gridHeight + maxAscent;
          modeSpecificDrawLine(g2, userText[i], lineStartX, lineStartY);
        }
      else {
        float xPos, yPos = (floatcanvasInset_Y;
        g2.drawRect(00, w - 1, h - 1);
        if (!isPrinting)
          g.drawImage(backBuffer, 00this);

        for (int i = drawStart; i <= drawEnd; i++) {
          TextLayout oneLine = (TextLayoutlineBreakTLs.elementAt(i);
          xPos = oneLine.isLeftToRight() ? canvasInset_X
              ((floatw - oneLine.getAdvance() - canvasInset_X);

          float fmData[] 0, oneLine.getAscent()0, oneLine.getDescent()0,
              oneLine.getLeading() };
          if (g2Transform != NONE) {
            AffineTransform at = getAffineTransform(g2Transform);
            at.transform(fmData, 0, fmData, 03);
          }
          // yPos += oneLine.getAscent();
          yPos += fmData[1]// ascent
          // oneLine.draw( g2, xPos, yPos );
          tlDrawLine(g2, oneLine, xPos, yPos);
          // yPos += oneLine.getDescent() + oneLine.getLeading();
          yPos += fmData[3+ fmData[5]// descent + leading
        }
      }
      if (!isPrinting)
        g.drawImage(backBuffer, 00this);
      g2.dispose();
    }

    // / Component paintComponent function...
    // / Draws/Refreshes canvas according to flag(s) set by other functions
    public void paintComponent(Graphics g) {
      if (updateBackBuffer) {
        Dimension d = this.getSize();
        isPrinting = false;
        try {
          drawText(g, d.width, d.height);
        catch (CannotDrawException e) {
          f2dt.fireChangeStatus(ERRORS[e.id]true);
          super.paintComponent(g);
          return;
        }
      else {
        // / Screen refresh
        g.drawImage(backBuffer, 00this);
      }

      showingError = false;
      updateBackBuffer = false;
    }

    // / Printable interface function
    // / Component print function...
    public int print(Graphics g, PageFormat pf, int pageIndex) {
      if (pageIndex == 0) {
        // / Reset the last page index to max...
        lastPage = Integer.MAX_VALUE;
        currentlyShownChar = verticalBar.getValue() * numCharAcross;
      }

      if (printMode == ONE_PAGE) {
        if (pageIndex > 0)
          return NO_SUCH_PAGE;
      else {
        if (pageIndex > lastPage)
          return NO_SUCH_PAGE;
      }

      int pageWidth = (intpf.getImageableWidth();
      int pageHeight = (intpf.getImageableHeight();
      // / Back up metrics and other drawing info before printing modifies it
      int backupDrawStart = drawStart, backupDrawEnd = drawEnd;
      int backupNumCharAcross = numCharAcross, backupNumCharDown = numCharDown;
      Vector backupLineBreakTLs = null;
      if (textToUse == FILE_TEXT)
        backupLineBreakTLs = (VectorlineBreakTLs.clone();

      printPageNumber = pageIndex;
      isPrinting = true;
      // / Push the actual draw area 60 down to allow info to be printed
      g.translate((intpf.getImageableX()(intpf.getImageableY() 60);
      try {
        drawText(g, pageWidth, pageHeight - 60);
      catch (CannotDrawException e) {
        f2dt.fireChangeStatus(ERRORS[e.id]true);
        return NO_SUCH_PAGE;
      }

      // / Draw information about what is being printed
      String hints = (" with antialias " + antiAliasType + "and" " fractional metrics "
          + fractionalMetricsType + " and lcd contrast = " + lcdContrast);
      String infoLine1 = ("Printing" + MS_OPENING[textToUse+ modeSpecificNumStr(drawStart)
          " to " + modeSpecificNumStr(drawEnd+ MS_CLOSING[textToUse]);
      String infoLine2 = ("With " + fontName + " " + STYLES[fontStyle" at " + fontSize
          " point size " + TRANSFORMS[fontTransform]);
      String infoLine3 = "Using " + METHODS[drawMethod+ hints;
      String infoLine4 = "Page: " (pageIndex + 1);
      g.setFont(new Font("dialog", Font.PLAIN, 12));
      g.setColor(Color.black);
      g.translate(0, -60);
      g.drawString(infoLine1, 1510);
      g.drawString(infoLine2, 1522);
      g.drawString(infoLine3, 1534);
      g.drawString(infoLine4, 1546);

      if (drawEnd == drawLimit)
        // / This indicates that the draw will be completed with this page
        lastPage = pageIndex;

      // / Restore the changed values back...
      // / This is important for JScrollBar settings and LineBreak'ed TLs
      drawStart = backupDrawStart;
      drawEnd = backupDrawEnd;
      numCharAcross = backupNumCharAcross;
      numCharDown = backupNumCharDown;
      if (textToUse == FILE_TEXT)
        lineBreakTLs = backupLineBreakTLs;
      return PAGE_EXISTS;
    }

    // / Ouputs the current canvas into a given PNG file
    public void writePNG(String fileName) {
      try {
        ImageIO.write(backBuffer, "png"new java.io.File(fileName));
      catch (Exception e) {
        f2dt.fireChangeStatus("ERROR: Failed to Save PNG image; See stack trace"true);
        e.printStackTrace();
      }
    }

    // / Figures out whether a character at the pointer location is valid
    // / And if so, updates mouse location informations, as well as
    // / the information on the status bar
    private boolean checkMouseLoc(MouseEvent e) {
      if (gridWidth != && gridHeight != 0)
        if (textToUse == RANGE_TEXT || textToUse == ALL_GLYPHS) {
          int charLocX = (e.getX() - canvasInset_X/ gridWidth;
          int charLocY = (e.getY() - canvasInset_Y/ gridHeight;

          // / Check to make sure the mouse click location is within drawn area
          if (charLocX >= && charLocY >= && charLocX < numCharAcross && charLocY < numCharDown) {
            int mouseOverChar = charLocX + (verticalBar.getValue() + charLocY* numCharAcross;
            if (textToUse == RANGE_TEXT)
              mouseOverChar += drawRange[0];
            if (mouseOverChar > drawEnd)
              return false;

            mouseOverCharX = charLocX;
            mouseOverCharY = charLocY;
            currMouseOverChar = mouseOverChar;
            // / Update status bar
            f2dt.fireChangeStatus("Pointing to" + MS_OPENING[textToUse]
                + modeSpecificNumStr(mouseOverChar)false);
            return true;
          }
        }
      return false;
    }

    // / Shows (updates) the character zoom window
    public void showZoomed() {
      GlyphVector gv;
      Font backup = testFont;
      Point canvasLoc = this.getLocationOnScreen();

      // / Calculate the zoom area's location and size...
      int dialogOffsetX = (int) (gridWidth * (ZOOM - 12);
      int dialogOffsetY = (int) (gridHeight * (ZOOM - 12);
      int zoomAreaX = mouseOverCharX * gridWidth + canvasInset_X - dialogOffsetX;
      int zoomAreaY = mouseOverCharY * gridHeight + canvasInset_Y - dialogOffsetY;
      int zoomAreaWidth = (int) (gridWidth * ZOOM);
      int zoomAreaHeight = (int) (gridHeight * ZOOM);

      // / Position and set size of zoom window as needed
      zoomWindow.setLocation(canvasLoc.x + zoomAreaX, canvasLoc.y + zoomAreaY);
      if (!nowZooming) {
        if (zoomWindow.getWarningString() != null)
          // / If this is not opened as a "secure" window,
          // / it has a banner below the zoom dialog which makes it look really
          // BAD
          // / So enlarge it by a bit
          zoomWindow.setSize(zoomAreaWidth + 1, zoomAreaHeight + 20);
        else
          zoomWindow.setSize(zoomAreaWidth + 1, zoomAreaHeight + 1);
      }

      // / Prepare zoomed image
      zoomImage = (BufferedImagezoomWindow.createImage(zoomAreaWidth + 1, zoomAreaHeight + 1);
      Graphics2D g2 = (Graphics2DzoomImage.getGraphics();
      testFont = testFont.deriveFont(fontSize * ZOOM);
      setParams(g2);
      g2.setColor(Color.white);
      g2.fillRect(00, zoomAreaWidth, zoomAreaHeight);
      g2.setColor(Color.black);
      g2.drawRect(00, zoomAreaWidth, zoomAreaHeight);
      modeSpecificDrawChar(g2, currMouseOverChar, zoomAreaWidth / 2(int) (maxAscent * ZOOM));
      g2.dispose();
      if (!nowZooming)
        zoomWindow.show();
      // / This is sort of redundant... since there is a paint function
      // / inside zoomWindow definition that does the drawImage.
      // / (I should be able to call just repaint() here)
      // / However, for some reason, that paint function fails to respond
      // / from second time and on; So I have to force the paint here...
      zoomWindow.getGraphics().drawImage(zoomImage, 00this);

      nowZooming = true;
      prevZoomChar = currMouseOverChar;
      testFont = backup;

      // Windows does not repaint correctly, after
      // a zoom. Thus, we need to force the canvas
      // to repaint, but only once. After the first repaint,
      // everything stabilizes. [ABP]
      if (firstTime()) {
        refresh();
      }
    }

    // / Listener Functions

    // / MouseListener interface function
    // / Zooms a character when mouse is pressed above it
    public void mousePressed(MouseEvent e) {
      if (!showingError) {
        if (checkMouseLoc(e)) {
          showZoomed();
          this.setCursor(blankCursor);
        }
      }
    }

    // / MouseListener interface function
    // / Redraws the area that was drawn over by zoomed character
    public void mouseReleased(MouseEvent e) {
      if (textToUse == RANGE_TEXT || textToUse == ALL_GLYPHS) {
        if (nowZooming)
          zoomWindow.hide();
        nowZooming = false;
      }
      this.setCursor(Cursor.getDefaultCursor());
    }

    // / MouseListener interface function
    // / Resets the status bar to display range instead of a specific character
    public void mouseExited(MouseEvent e) {
      if (!showingError && !nowZooming)
        f2dt.fireChangeStatus(backupStatusString, false);
    }

    // / MouseMotionListener interface function
    // / Adjusts the status bar message when mouse moves over a character
    public void mouseMoved(MouseEvent e) {
      if (!showingError) {
        if (!checkMouseLoc(e))
          f2dt.fireChangeStatus(backupStatusString, false);
      }
    }

    // / MouseMotionListener interface function
    // / Scrolls the zoomed character when mouse is dragged
    public void mouseDragged(MouseEvent e) {
      if (!showingError)
        if (nowZooming) {
          if (checkMouseLoc(e&& currMouseOverChar != prevZoomChar)
            showZoomed();
        }
    }

    // / Empty function to comply with interface requirement
    public void mouseClicked(MouseEvent e) {
    }

    public void mouseEntered(MouseEvent e) {
    }
  }

  private final class CannotDrawException extends RuntimeException {
    // / Error ID
    public final int id;

    public CannotDrawException(int i) {
      id = i;
    }
  }

  enum FMValues {
    FMDEFAULT("DEFAULT", VALUE_FRACTIONALMETRICS_DEFAULT), FMOFF("OFF", VALUE_FRACTIONALMETRICS_OFF), FMON(
        "ON", VALUE_FRACTIONALMETRICS_ON);

    private String name;

    private Object hint;

    private static FMValues[] valArray;

    FMValues(String s, Object o) {
      name = s;
      hint = o;
    }

    public String toString() {
      return name;
    }

    public Object getHint() {
      return hint;
    }

    public static Object getValue(int ordinal) {
      if (valArray == null) {
        valArray = (FMValues[]) EnumSet.allOf(FMValues.class).toArray(new FMValues[0]);
      }
      for (int i = 0; i < valArray.length; i++) {
        if (valArray[i].ordinal() == ordinal) {
          return valArray[i];
        }
      }
      return valArray[0];
    }

    private static FMValues[] getArray() {
      if (valArray == null) {
        valArray = (FMValues[]) EnumSet.allOf(FMValues.class).toArray(new FMValues[0]);
      }
      return valArray;
    }

    public static int getHintVal(Object hint) {
      getArray();
      for (int i = 0; i < valArray.length; i++) {
        if (valArray[i].getHint() == hint) {
          return i;
        }
      }
      return 0;
    }
  }

  enum AAValues {
    AADEFAULT("DEFAULT", VALUE_TEXT_ANTIALIAS_DEFAULT), AAOFF("OFF", VALUE_TEXT_ANTIALIAS_OFF), AAON(
        "ON", VALUE_TEXT_ANTIALIAS_ON), AAGASP("GASP", VALUE_TEXT_ANTIALIAS_GASP), AALCDHRGB(
        "LCD_HRGB", VALUE_TEXT_ANTIALIAS_LCD_HRGB), AALCDHBGR("LCD_HBGR",
        VALUE_TEXT_ANTIALIAS_LCD_HBGR), AALCDVRGB("LCD_VRGB", VALUE_TEXT_ANTIALIAS_LCD_VRGB), AALCDVBGR(
        "LCD_VBGR", VALUE_TEXT_ANTIALIAS_LCD_VBGR);

    private String name;

    private Object hint;

    private static AAValues[] valArray;

    AAValues(String s, Object o) {
      name = s;
      hint = o;
    }

    public String toString() {
      return name;
    }

    public Object getHint() {
      return hint;
    }

    public static boolean isLCDMode(Object o) {
      return (instanceof AAValues && ((AAValueso).ordinal() >= AALCDHRGB.ordinal());
    }

    public static Object getValue(int ordinal) {
      if (valArray == null) {
        valArray = (AAValues[]) EnumSet.allOf(AAValues.class).toArray(new AAValues[0]);
      }
      for (int i = 0; i < valArray.length; i++) {
        if (valArray[i].ordinal() == ordinal) {
          return valArray[i];
        }
      }
      return valArray[0];
    }

    private static AAValues[] getArray() {
      if (valArray == null) {
        Object[] oa = EnumSet.allOf(AAValues.class).toArray(new AAValues[0]);
        valArray = (AAValues[]) (EnumSet.allOf(AAValues.class).toArray(new AAValues[0]));
      }
      return valArray;
    }

    public static int getHintVal(Object hint) {
      getArray();
      for (int i = 0; i < valArray.length; i++) {
        if (valArray[i].getHint() == hint) {
          return i;
        }
      }
      return 0;
    }

  }

  private static Integer defaultContrast;

  static Integer getDefaultLCDContrast() {
    if (defaultContrast == null) {
      GraphicsConfiguration gc = GraphicsEnvironment.getLocalGraphicsEnvironment()
          .getDefaultScreenDevice().getDefaultConfiguration();
      Graphics2D g2d = (Graphics2D) (gc.createCompatibleImage(11).getGraphics());
      defaultContrast = (Integerg2d.getRenderingHint(RenderingHints.KEY_TEXT_LCD_CONTRAST);
    }
    return defaultContrast;
  }
}

/*
 * @(#)RangeMenu.java 1.18 05/11/17
 
 * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 
 * -Redistribution of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer.
 
 * -Redistribution in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 
 * Neither the name of Sun Microsystems, Inc. or the names of contributors may
 * be used to endorse or promote products derived from this software without
 * specific prior written permission.
 
 * This software is provided "AS IS," without a warranty of any kind. ALL
 * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
 * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
 * NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN MIDROSYSTEMS, INC. ("SUN") AND ITS
 * LICENSORS SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED BY LICENSEE AS A
 * RESULT OF USING, MODIFYING OR DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
 * IN NO EVENT WILL SUN OR ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT
 * OR DATA, OR FOR DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR
 * PUNITIVE DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
 * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF SUN HAS
 * BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 
 * You acknowledge that this software is not designed, licensed or intended for
 * use in the design, construction, operation or maintenance of any nuclear
 * facility.
 */

/*
 * @(#)RangeMenu.java 1.18 05/11/17
 */

/**
 * RangeMenu.java
 
 @version
 * @(#)RangeMenu.java 1.1 00/08/22
 @author Shinsuke Fukuda
 @author Ankit Patel [Conversion to Swing - 01/07/30]
 */

// / Custom made choice menu that holds data for unicode range
final class RangeMenu extends JComboBox implements ActionListener {

  // / Painfully extracted from java.lang.Character.UnicodeBlock. Arrrgh!
  // / Unicode 3.0 data.

  private final int[][] UNICODE_RANGES = { { 0x0000000x00007f }// /
                                                                    // BASIC_LATIN
      0x0000800x0000ff }// / LATIN_1_SUPPLEMENT
      0x0001000x00017f }// / LATIN_EXTENDED_A
      0x0001800x00024f }// / LATIN_EXTENDED_B
      0x0002500x0002af }// / IPA_EXTENSIONS
      0x0002b00x0002ff }// / SPACING_MODIFIER_LETTERS
      0x0003000x00036f }// / COMBINING_DIACRITICAL_MARKS
      0x0003700x0003ff }// / GREEK
      0x0004000x0004ff }// / CYRILLIC
      0x0005000x00052f }// / CYRILLIC_SUPPLEMENTARY
      0x0005300x00058f }// / ARMENIAN
      0x0005900x0005ff }// / HEBREW
      0x0006000x0006ff }// / ARABIC
      0x0007000x00074f }// / SYRIAC
      0x0007800x0007bf }// / THAANA
      0x0009000x00097f }// / DEVANAGARI
      0x0009800x0009ff }// / BENGALI
      0x000a000x000a7f }// / GURMUKHI
      0x000a800x000aff }// / GUJARATI
      0x000b000x000b7f }// / ORIYA
      0x000b800x000bff }// / TAMIL
      0x000c000x000c7f }// / TELUGU
      0x000c800x000cff }// / KANNADA
      0x000d000x000d7f }// / MALAYALAM
      0x000d800x000dff }// / SINHALA
      0x000e000x000e7f }// / THAI
      0x000e800x000eff }// / LAO
      0x000f000x000fff }// / TIBETAN
      0x0010000x00109f }// / MYANMAR
      0x0010a00x0010ff }// / GEORGIAN
      0x0011000x0011ff }// / HANGUL_JAMO
      0x0012000x00137f }// / ETHIOPIC
      0x0013a00x0013ff }// / CHEROKEE
      0x0014000x00167f }// / UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS
      0x0016800x00169f }// / OGHAM
      0x0016a00x0016ff }// / RUNIC
      0x0017000x00171f }// / TAGALOG
      0x0017200x00173f }// / HANUNOO
      0x0017400x00175f }// / BUHID
      0x0017600x00177f }// / TAGBANWA
      0x0017800x0017ff }// / KHMER
      0x0018000x0018af }// / MONGOLIAN
      0x0019000x00194f }// / LIMBU
      0x0019500x00197f }// / TAI_LE
      0x0019e00x0019ff }// / KHMER_SYMBOLS
      0x001d000x001d7f }// / PHONETIC_EXTENSIONS
      0x001e000x001eff }// / LATIN_EXTENDED_ADDITIONAL
      0x001f000x001fff }// / GREEK_EXTENDED
      0x0020000x00206f }// / GENERAL_PUNCTUATION
      0x0020700x00209f }// / SUPERSCRIPTS_AND_SUBSCRIPTS
      0x0020a00x0020cf }// / CURRENCY_SYMBOLS
      0x0020d00x0020ff }// / COMBINING_MARKS_FOR_SYMBOLS
      0x0021000x00214f }// / LETTERLIKE_SYMBOLS
      0x0021500x00218f }// / NUMBER_FORMS
      0x0021900x0021ff }// / ARROWS
      0x0022000x0022ff }// / MATHEMATICAL_OPERATORS
      0x0023000x0023ff }// / MISCELLANEOUS_TECHNICAL
      0x0024000x00243f }// / CONTROL_PICTURES
      0x0024400x00245f }// / OPTICAL_CHARACTER_RECOGNITION
      0x0024600x0024ff }// / ENCLOSED_ALPHANUMERICS
      0x0025000x00257f }// / BOX_DRAWING
      0x0025800x00259f }// / BLOCK_ELEMENTS
      0x0025a00x0025ff }// / GEOMETRIC_SHAPES
      0x0026000x0026ff }// / MISCELLANEOUS_SYMBOLS
      0x0027000x0027bf }// / DINGBATS
      0x0027c00x0027ef }// / MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A
      0x0027f00x0027ff }// / SUPPLEMENTAL_ARROWS_A
      0x0028000x0028ff }// / BRAILLE_PATTERNS
      0x0029000x00297f }// / SUPPLEMENTAL_ARROWS_B
      0x0029800x0029ff }// / MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B
      0x002a000x002aff }// / SUPPLEMENTAL_MATHEMATICAL_OPERATORS
      0x002b000x002bff }// / MISCELLANEOUS_SYMBOLS_AND_ARROWS
      0x002e800x002eff }// / CJK_RADICALS_SUPPLEMENT
      0x002f000x002fdf }// / KANGXI_RADICALS
      0x002ff00x002fff }// / IDEOGRAPHIC_DESCRIPTION_CHARACTERS
      0x0030000x00303f }// / CJK_SYMBOLS_AND_PUNCTUATION
      0x0030400x00309f }// / HIRAGANA
      0x0030a00x0030ff }// / KATAKANA
      0x0031000x00312f }// / BOPOMOFO
      0x0031300x00318f }// / HANGUL_COMPATIBILITY_JAMO
      0x0031900x00319f }// / KANBUN
      0x0031a00x0031bf }// / BOPOMOFO_EXTENDED
      0x0031f00x0031ff }// / KATAKANA_PHONETIC_EXTENSIONS
      0x0032000x0032ff }// / ENCLOSED_CJK_LETTERS_AND_MONTHS
      0x0033000x0033ff }// / CJK_COMPATIBILITY
      0x0034000x004dbf }// / CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
      0x004dc00x004dff }// / YIJING_HEXAGRAM_SYMBOLS
      0x004e000x009fff }// / CJK_UNIFIED_IDEOGRAPHS
      0x00a0000x00a48f }// / YI_SYLLABLES
      0x00a4900x00a4cf }// / YI_RADICALS
      0x00ac000x00d7af }// / HANGUL_SYLLABLES
      0x00d8000x00dfff }// / SURROGATES_AREA
      0x00e0000x00f8ff }// / PRIVATE_USE_AREA
      0x00f9000x00faff }// / CJK_COMPATIBILITY_IDEOGRAPHS
      0x00fb000x00fb4f }// / ALPHABETIC_PRESENTATION_FORMS
      0x00fb500x00fdff }// / ARABIC_PRESENTATION_FORMS_A
      0x00fe000x00fe0f }// / VARIATION_SELECTORS
      0x00fe200x00fe2f }// / COMBINING_HALF_MARKS
      0x00fe300x00fe4f }// / CJK_COMPATIBILITY_FORMS
      0x00fe500x00fe6f }// / SMALL_FORM_VARIANTS
      0x00fe700x00feff }// / ARABIC_PRESENTATION_FORMS_B
      0x00ff000x00ffef }// / HALFWIDTH_AND_FULLWIDTH_FORMS
      0x00fff00x00ffff }// / SPECIALS
      0x0100000x01007f }// / LINEAR_B_SYLLABARY
      0x0100800x0100ff }// / LINEAR_B_IDEOGRAMS
      0x0101000x01013f }// / AEGEAN_NUMBERS
      0x0103000x01032f }// / OLD_ITALIC
      0x0103300x01034f }// / GOTHIC
      0x0103800x01039f }// / UGARITIC
      0x0104000x01044f }// / DESERET
      0x0104500x01047f }// / SHAVIAN
      0x0104800x0104af }// / OSMANYA
      0x0108000x01083f }// / CYPRIOT_SYLLABARY
      0x01d0000x01d0ff }// / BYZANTINE_MUSICAL_SYMBOLS
      0x01d1000x01d1ff }// / MUSICAL_SYMBOLS
      0x01d3000x01d35f }// / TAI_XUAN_JING_SYMBOLS
      0x01d4000x01d7ff }// / MATHEMATICAL_ALPHANUMERIC_SYMBOLS
      0x0200000x02a6df }// / CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B
      0x02f8000x02fa1f }// / CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT
      0x0e00000x0e007f }// / TAGS
      0x0e01000x0e01ef }// / VARIATION_SELECTORS_SUPPLEMENT
      0x0f00000x0fffff }// / SUPPLEMENTARY_PRIVATE_USE_AREA_A
      0x1000000x10ffff }// / SUPPLEMENTARY_PRIVATE_USE_AREA_B
      0x0000000x00007f }// / OTHER [USER DEFINED RANGE]
  };

  private final String[] UNICODE_RANGE_NAMES = "Basic Latin""Latin-1 Supplement",
      "Latin Extended-A""Latin Extended-B""IPA Extensions""Spacing Modifier Letters",
      "Combining Diacritical Marks""Greek""Cyrillic""Cyrillic Supplement""Armenian",
      "Hebrew""Arabic""Syriac""Thaana""Devanagari""Bengali""Gurmukhi""Gujarati",
      "Oriya""Tamil""Telugu""Kannada""Malayalam""Sinhala""Thai""Lao""Tibetan",
      "Myanmar""Georgian""Hangul Jamo""Ethiopic""Cherokee",
      "Unified Canadian Aboriginal Syllabics""Ogham""Runic""Tagalog""Hanunoo""Buhid",
      "Tagbanwa""Khmer""Mongolian""Limbu""Tai Le""Khmer Symbols""Phonetic Extensions",
      "Latin Extended Additional""Greek Extended""General Punctuation",
      "Superscripts and Subscripts""Currency Symbols""Combining Marks for Symbols",
      "Letterlike Symbols""Number Forms""Arrows""Mathematical Operators",
      "Miscellaneous Technical""Control Pictures""Optical Character Recognition",
      "Enclosed Alphanumerics""Box Drawing""Block Elements""Geometric Shapes",
      "Miscellaneous Symbols""Dingbats""Miscellaneous Mathematical Symbols-A",
      "Supplemental Arrows-A""Braille Patterns""Supplemental Arrows-B",
      "Miscellaneous Mathematical Symbols-B""Supplemental Mathematical Operators",
      "Miscellaneous Symbols and Arrows""CJK Radicals Supplement""Kangxi Radicals",
      "Ideographic Description Characters""CJK Symbols and Punctuation""Hiragana""Katakana",
      "Bopomofo""Hangul Compatibility Jamo""Kanbun""Bopomofo Extended",
      "Katakana Phonetic Extensions""Enclosed CJK Letters and Months""CJK Compatibility",
      "CJK Unified Ideographs Extension A""Yijing Hexagram Symbols""CJK Unified Ideographs",
      "Yi Syllables""Yi Radicals""Hangul Syllables""Surrogates Area"// High
                                                                            // Surrogates,
                                                                            // High
                                                                            // Private
                                                                            // Use
                                                                            // Surrogates,
                                                                            // Low
                                                                            // Surrogates
      "Private Use Area""CJK Compatibility Ideographs""Alphabetic Presentation Forms",
      "Arabic Presentation Forms-A""Variation Selectors""Combining Half Marks",
      "CJK Compatibility Forms""Small Form Variants""Arabic Presentation Forms-B",
      "Halfwidth and Fullwidth Forms""Specials""Linear B Syllabary""Linear B Ideograms",
      "Aegean Numbers""Old Italic""Gothic""Ugaritic""Deseret""Shavian""Osmanya",
      "Cypriot Syllabary""Byzantine Musical Symbols""Musical Symbols""Tai Xuan Jing Symbols",
      "Mathematical Alphanumeric Symbols""CJK Unified Ideographs Extension B",
      "CJK Compatibility Ideographs Supplement""Tags""Variation Selectors Supplement",
      "Supplementary Private Use Area-A""Supplementary Private Use Area-B""Custom..."};

  private boolean useCustomRange = false;

  private int[] customRange = 0x00000x007f };

  // / Custom range dialog variables
  private final JDialog customRangeDialog;

  private final JTextField customRangeStart = new JTextField("0000"4);

  private final JTextField customRangeEnd = new JTextField("007F"4);

  private final int CUSTOM_RANGE_INDEX = UNICODE_RANGE_NAMES.length - 1;

  // / Parent Font2DTest Object holder
  private final Font2DTest parent;

  public static final int SURROGATES_AREA_INDEX = 91;

  public RangeMenu(Font2DTest demo, JFrame f) {
    super();
    parent = demo;

    for (int i = 0; i < UNICODE_RANGE_NAMES.length; i++)
      addItem(UNICODE_RANGE_NAMES[i]);

    setSelectedIndex(0);
    addActionListener(this);

    // / Set up custom range dialog...
    customRangeDialog = new JDialog(f, "Custom Unicode Range"true);
    customRangeDialog.setResizable(false);

    JPanel dialogTop = new JPanel();
    JPanel dialogBottom = new JPanel();
    JButton okButton = new JButton("OK");
    JLabel from new JLabel("From:");
    JLabel to = new JLabel("To:");
    Font labelFont = new Font("dialog", Font.BOLD, 12);
    from.setFont(labelFont);
    to.setFont(labelFont);
    okButton.setFont(labelFont);

    dialogTop.add(from);
    dialogTop.add(customRangeStart);
    dialogTop.add(to);
    dialogTop.add(customRangeEnd);
    dialogBottom.add(okButton);
    okButton.addActionListener(this);

    customRangeDialog.getContentPane().setLayout(new BorderLayout());
    customRangeDialog.getContentPane().add("North", dialogTop);
    customRangeDialog.getContentPane().add("South", dialogBottom);
    customRangeDialog.pack();
  }

  // / Return the range that is currently selected

  public int[] getSelectedRange() {
    if (useCustomRange) {
      int startIndex, endIndex;
      String startText, endText;
      String empty = "";
      try {
        startText = customRangeStart.getText().trim();
        endText = customRangeEnd.getText().trim();
        if (startText.equals(empty&& !endText.equals(empty)) {
          endIndex = Integer.parseInt(endText, 16);
          startIndex = endIndex - 25;
        else if (!startText.equals(empty&& endText.equals(empty)) {
          startIndex = Integer.parseInt(startText, 16);
          endIndex = startIndex + 25;
        else {
          startIndex = Integer.parseInt(customRangeStart.getText()16);
          endIndex = Integer.parseInt(customRangeEnd.getText()16);
        }
      catch (Exception e) {
        // / Error in parsing the hex number ---
        // / Reset the range to what it was before and return that
        customRangeStart.setText(Integer.toString(customRange[0]16));
        customRangeEnd.setText(Integer.toString(customRange[1]16));
        return customRange;
      }

      if (startIndex < 0)
        startIndex = 0;
      if (endIndex > 0xffff)
        endIndex = 0xffff;
      if (startIndex > endIndex)
        startIndex = endIndex;

      customRange[0= startIndex;
      customRange[1= endIndex;
      return customRange;
    else
      return UNICODE_RANGES[getSelectedIndex()];
  }

  // / Function used by loadOptions in Font2DTest main panel
  // / to reset setting and range selection
  public void setSelectedRange(String name, int start, int end) {
    setSelectedItem(name);
    customRange[0= start;
    customRange[1end;
    parent.fireRangeChanged();
  }

  // / ActionListener interface function
  // / ABP
  // / moved JComboBox event code into this fcn from
  // / itemStateChanged() method. Part of change to Swing.
  public void actionPerformed(ActionEvent e) {
    Object source = e.getSource();

    if (source instanceof JComboBox) {
      String rangeName = (String) ((JComboBoxsource).getSelectedItem();

      if (rangeName.equals("Custom...")) {
        useCustomRange = true;
        customRangeDialog.setLocationRelativeTo(parent);
        customRangeDialog.show();
      else {
        useCustomRange = false;
      }
      parent.fireRangeChanged();
    else if (source instanceof JButton) {
      // / Since it is only "OK" button that sends any action here...
      customRangeDialog.hide();
    }
  }
}

        
Related examples in the same category
1. 字体选择源代码字体选择源代码
2. JFreeChart :字体对话框JFreeChart :字体对话框
www.java2java.com | Contact Us
Copyright 2010 - 2030 Java Source and Support. All rights reserved.
All other trademarks are property of their respective owners.