/* * Copyright (c) 1999, 2024, Oracle and/or its affiliates. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * - Redistributions 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 Oracle nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* * This source code is provided to illustrate the usage of a given feature * or technique and has been deliberately simplified. Additional steps * required for a production-quality application, such as security checks, * input validation and proper error handling, might not be present in * this sample code. */ import java.awt.Color; import java.awt.Component; import java.awt.BorderLayout; import java.awt.CheckboxGroup; import java.awt.Container; import java.awt.Dimension; import java.awt.Font; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.GraphicsEnvironment; import java.awt.GridBagConstraints; import java.awt.GridBagLayout; import java.awt.GridLayout; import java.awt.Insets; import java.awt.RenderingHints; import java.awt.Toolkit; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.ItemEvent; import java.awt.event.ItemListener; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; import java.awt.image.BufferedImage; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.lang.reflect.InvocationTargetException; import java.util.StringTokenizer; import java.util.ArrayList; import java.util.BitSet; import java.util.HashMap; import java.util.List; import java.util.Locale; import java.util.Map; import javax.swing.*; import javax.swing.event.*; import javax.swing.plaf.nimbus.NimbusLookAndFeel; import static java.nio.charset.StandardCharsets.UTF_16; 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 JPanel fontMenuPanel; private JPanel stylePanel; private LabelV2 fontMenuLabel = null; private LabelV2 styleLabel = null; private ChoiceV2 fontNameMenu; private ChoiceV2 fontSubFamilyMenu; 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; private JRadioButtonMenuItem familyAndStyleRBMI; private JRadioButtonMenuItem familyAndSubFamilyRBMI; private JRadioButtonMenuItem fontNameRBMI; /// 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 String currentFontName = Font.DIALOG; 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; private static final Locale l = Locale.getDefault(); /// Initialize GUI variables and its layouts public Font2DTest( JFrame f) { parent = f; rm = new RangeMenu( this, parent ); fp = new FontPanel( this, parent ); statusBar = new LabelV2(""); fontMenu = new ChoiceV2( this, canDisplayCheck ); fontNameMenu = new ChoiceV2( this, false ); fontSubFamilyMenu = new ChoiceV2( this, false ); 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<>(FontPanel.AAValues.values()); antiAliasMenu.addActionListener(this); fracMetricsMenu = new JComboBox<>(FontPanel.FMValues.values()); fracMetricsMenu.addActionListener(this); contrastSlider = new JSlider(JSlider.HORIZONTAL, 100, 250, FontPanel.getDefaultLCDContrast().intValue()); contrastSlider.setEnabled(false); contrastSlider.setMajorTickSpacing(20); contrastSlider.setMinorTickSpacing(10); contrastSlider.setPaintTicks(true); contrastSlider.setPaintLabels(true); contrastSlider.addChangeListener(this); setupPanel(); setupMenu(); setupDialog(); if(canDisplayCheck) { fireRangeChanged(); } } private void addFontMenuToGBL(String labelText, JComponent menuContainer, GridBagLayout gbl, GridBagConstraints gbc, int leftInset, Container target) { fontMenuLabel = new LabelV2(labelText); fontMenuLabel.setLabelFor(menuContainer); GridBagConstraints gbcLabel = (GridBagConstraints) gbc.clone(); gbcLabel.insets = new Insets(2, leftInset, 2, 0); gbcLabel.gridwidth = 1; gbcLabel.weightx = 0; gbcLabel.anchor = GridBagConstraints.EAST; gbl.setConstraints(fontMenuLabel, gbcLabel); target.add(fontMenuLabel); gbl.setConstraints(menuContainer, gbc); target.add( menuContainer ); } private void addStyleMenuToGBL(String labelText, JComponent menuContainer, GridBagLayout gbl, GridBagConstraints gbc, int leftInset, Container target) { styleLabel = new LabelV2(labelText); styleLabel.setLabelFor(menuContainer); GridBagConstraints gbcLabel = (GridBagConstraints) gbc.clone(); gbcLabel.insets = new Insets(2, leftInset, 2, 0); gbcLabel.gridwidth = 1; gbcLabel.weightx = 0; gbcLabel.anchor = GridBagConstraints.EAST; gbl.setConstraints(styleLabel, gbcLabel); target.add(styleLabel); gbl.setConstraints(menuContainer, gbc); target.add(menuContainer); } /// 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( 2, 0, 2, 2 ); this.setLayout( gbl ); fontMenuPanel = new JPanel(); fontMenuPanel.setLayout(new GridLayout()); fontMenuPanel.add(fontMenu); addFontMenuToGBL(FAMILY_LABEL_TEXT, fontMenuPanel, gbl, gbc, 2, this ); stylePanel = new JPanel(); stylePanel.setLayout(new GridLayout()); stylePanel.add(styleMenu); addStyleMenuToGBL(STYLE_LABEL_TEXT, stylePanel, gbl, gbc, 40, this ); gbc.gridwidth = GridBagConstraints.REMAINDER; addLabeledComponentToGBL( "Font Transform:", transformMenu, gbl, gbc, 20, this ); gbc.gridwidth = 1; addLabeledComponentToGBL( "Range: ", rm, gbl, gbc, 2, this ); addLabeledComponentToGBL( "Size: ", sizeField, gbl, gbc, 40, this ); gbc.gridwidth = GridBagConstraints.REMAINDER; addLabeledComponentToGBL( "Graphics Transform: ", transformMenuG2, gbl, gbc, 20, this ); gbc.gridwidth = 1; gbc.anchor = GridBagConstraints.WEST; addLabeledComponentToGBL( "Method: ", methodsMenu, gbl, gbc, 2, this ); addLabeledComponentToGBL("", null, gbl, gbc, 40, this); gbc.anchor = GridBagConstraints.EAST; gbc.gridwidth = GridBagConstraints.REMAINDER; addLabeledComponentToGBL( "Text to use:", textMenu, gbl, gbc, 20, this ); gbc.gridwidth = 1; gbc.anchor = GridBagConstraints.WEST; addLabeledComponentToGBL("LCD contrast: ", contrastSlider, gbl, gbc, 2, this); gbc.gridwidth = 1; addLabeledComponentToGBL("Antialiasing: ", antiAliasMenu, gbl, gbc, 40, this); gbc.anchor = GridBagConstraints.EAST; gbc.gridwidth = GridBagConstraints.REMAINDER; addLabeledComponentToGBL("Fractional metrics: ", fracMetricsMenu, gbl, gbc, 20, this); gbc.weightx = 1; gbc.weighty = 1; gbc.anchor = GridBagConstraints.WEST; gbc.insets = new Insets( 2, 0, 0, 2 ); gbc.fill = GridBagConstraints.BOTH; gbl.setConstraints( fp, gbc ); this.add( fp ); gbc.weighty = 0; gbc.insets = new Insets( 0, 2, 0, 0 ); 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, int leftInset, Container target ) { LabelV2 l = new LabelV2( name ); l.setLabelFor(c); GridBagConstraints gbcLabel = (GridBagConstraints) gbc.clone(); if (gbcLabel.gridwidth == GridBagConstraints.REMAINDER) { gbcLabel.gridwidth = GridBagConstraints.RELATIVE; } gbcLabel.insets = new Insets( 2, leftInset, 2, 0 ); gbcLabel.gridwidth = 1; gbcLabel.weightx = 0; if ( c == null ) c = new JLabel( "" ); gbcLabel.anchor = GridBagConstraints.EAST; gbl.setConstraints( l, gbcLabel ); target.add( l ); gbl.setConstraints( c, gbc ); target.add( c ); } /// Sets up menu entries private void setupMenu() { 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(); fileMenu.add( new MenuItemV2( "Exit", 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 ); optionMenu.addSeparator(); familyAndStyleRBMI = new JRadioButtonMenuItem("Select font using Family Name and Style"); familyAndStyleRBMI.addActionListener(this); familyAndSubFamilyRBMI = new JRadioButtonMenuItem("Select font using Family Name and SubFamily"); familyAndSubFamilyRBMI.addActionListener(this); fontNameRBMI = new JRadioButtonMenuItem("Select font using Full Name"); fontNameRBMI.addActionListener(this); ButtonGroup bg = new ButtonGroup(); bg.add(familyAndStyleRBMI); bg.add(familyAndSubFamilyRBMI); bg.add(fontNameRBMI); familyAndStyleRBMI.setSelected(true); optionMenu.add(familyAndStyleRBMI); optionMenu.add(familyAndSubFamilyRBMI); optionMenu.add(fontNameRBMI); JMenuBar mb = parent.getJMenuBar(); if ( mb == null ) mb = new JMenuBar(); mb.add( fileMenu ); mb.add( optionMenu ); parent.setJMenuBar( mb ); String[] fontList = getAllFamilyNames(); for (int i = 0; i < fontList.length; i++ ) { fontMenu.addItem( fontList[i] ); } fontMenu.setSelectedItem("Dialog"); fontList = getAllFontNames(); for (int i = 0; i < fontList.length; i++ ) { fontNameMenu.addItem( fontList[i] ); } fontNameMenu.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() { filePromptDialog = new JFileChooser(); /// 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( "Font2DTest!" ); ButtonV2 bUpdate = new ButtonV2( "Update", this ); userTextArea.setFont( new Font( "dialog", Font.PLAIN, 12 )); dialogTopPanel.setLayout( new GridLayout( 3, 1 )); dialogTopPanel.add( message1 ); dialogTopPanel.add( message2 ); dialogTopPanel.add( message3 ); dialogBottomPanel.add( bUpdate ); //ABP JScrollPane userTextAreaSP = new JScrollPane(userTextArea); userTextAreaSP.setPreferredSize(new Dimension(300, 100)); 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.setVisible(false); } }); /// Prepare printing dialog... printCBGroup = new ButtonGroup(); printModeCBs[ fp.ONE_PAGE ] = new JRadioButton( "Print one page from currently displayed character/line", true ); printModeCBs[ fp.CUR_RANGE ] = new JRadioButton( "Print all characters in currently selected range", false ); printModeCBs[ fp.ALL_TEXT ] = new 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.setVisible(false); } }); printDialog.getContentPane().setLayout( new GridLayout( printModeCBs.length + 2, 1 )); 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.setVisible(false); showFontInfoCBMI.setState( false ); } }); JPanel fontInfoPanel = new JPanel(); fontInfoPanel.setLayout( new GridLayout( fontInfos.length, 1 )); for ( int i = 0; i < fontInfos.length; i++ ) { fontInfos[i] = new LabelV2(""); fontInfoPanel.add( fontInfos[i] ); } fontInfoDialog.getContentPane().add( fontInfoPanel ); /// Move the location of the dialog... userTextDialog.setLocation( 200, 300 ); fontInfoDialog.setLocation( 0, 400 ); } /// 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 ) { 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 = fontMenu.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) ? -1 : nextSupEscape) : ((nextSupEscape < 0) ? nextBMPEscape : Math.min(nextBMPEscape, nextSupEscape)); if ( nextEscape != -1 ) { if ( prevEscapeEnd < nextEscape ) converted.append( oneLine.substring( prevEscapeEnd, nextEscape )); prevEscapeEnd = nextEscape + (nextEscape == nextBMPEscape ? 6 : 8); try { String hex = oneLine.substring( nextEscape + 2, prevEscapeEnd ); if (nextEscape == nextBMPEscape) { converted.append( (char) Integer.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; String[] 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] == (byte) 0xFF && byteData[1] == (byte) 0xFE ) || ( byteData[0] == (byte) 0xFE && byteData[1] == (byte) 0xFF ))) 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 - 1 && 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" + fontSelectionType + "\n" + (String)fontMenu.getSelectedItem() + "\n" + (String)fontNameMenu.getSelectedItem() + "\n" + (String)fontSubFamilyMenu.getSelectedItem() + "\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.setVisible(true); else userTextDialog.setVisible(false); /// 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 < 2 || (byteData[0] != (byte) 0xFE || byteData[1] != (byte) 0xFF) ) 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() ); int fontSelType = Integer.parseInt( perLine.nextToken() ); String fmItem = perLine.nextToken(); String fnmItem = perLine.nextToken(); String fsmItem = 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 = { "Font2DTest!" }; String dialogEntry = "Font2DTest!"; 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 ); currentFontName = fontNameOpt; setFontSelectionType(fontSelType); fontMenu.setSelectedItem( fmItem ); fontNameMenu.setSelectedItem( fnmItem ); fontSubFamilyMenu.setSelectedItem( fsmItem ); 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.setVisible(true); } else fontInfoDialog.setVisible(false); } 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 ) { ( (JFrame) e.getSource() ).dispose(); } }); f.pack(); f.setVisible(true); } catch ( Exception ex ) { fireChangeStatus( "ERROR: Failed to Load PNG File; See Stack Trace", true ); ex.printStackTrace(); } } static final int FAMILY_AND_STYLE = 1; static final int FONT_NAME = 2; static final int FAMILY_AND_SUBFAMILY = 3; static int fontSelectionType = FAMILY_AND_STYLE; static final String FAMILY_LABEL_TEXT = "Font Family:"; static final String NAME_LABEL_TEXT = "Font Name:"; static final String STYLE_LABEL_TEXT = "Style:"; static final String SUBFAMILY_LABEL_TEXT = "Subfamily:"; void setUseFamilyAndStyle() { if (fontSelectionType == FAMILY_AND_STYLE) { return; } fontMenuLabel.setText(FAMILY_LABEL_TEXT); fontMenuPanel.removeAll(); fontMenuPanel.add(fontMenu); if (fontSelectionType == FAMILY_AND_SUBFAMILY) { styleLabel.setText(STYLE_LABEL_TEXT); stylePanel.removeAll(); stylePanel.add(styleMenu); } fontSelectionType = FAMILY_AND_STYLE; if (!familyAndStyleRBMI.isSelected()) { familyAndStyleRBMI.setSelected(true); } styleMenu.setSelectedIndex(0); currentFontName = (String)fontMenu.getSelectedItem(); fp.setFontParams(currentFontName, Float.parseFloat(sizeField.getText()), 0, // want to reset style to PLAIN transformMenu.getSelectedIndex()); revalidate(); repaint(); } void setUseFontName() { if (fontSelectionType == FONT_NAME) { return; } fontMenuLabel.setText(NAME_LABEL_TEXT); fontMenuPanel.removeAll(); fontMenuPanel.add(fontNameMenu); if (fontSelectionType == FAMILY_AND_SUBFAMILY) { styleLabel.setText(STYLE_LABEL_TEXT); stylePanel.removeAll(); stylePanel.add(styleMenu); } fontSelectionType = FONT_NAME; if (!fontNameRBMI.isSelected()) { fontNameRBMI.setSelected(true); } styleMenu.setSelectedIndex(0); currentFontName = (String)fontNameMenu.getSelectedItem(); fp.setFontParams(currentFontName, Float.parseFloat(sizeField.getText()), 0, // want to reset style to PLAIN transformMenu.getSelectedIndex()); revalidate(); repaint(); } void setUseFamilyAndSubFamily() { if (fontSelectionType == FAMILY_AND_SUBFAMILY) { return; } fontMenuLabel.setText(FAMILY_LABEL_TEXT); fontMenuPanel.removeAll(); fontMenuPanel.add(fontMenu); styleLabel.setText(SUBFAMILY_LABEL_TEXT); stylePanel.removeAll(); styleMenu.setSelectedIndex(0); String family = (String)fontMenu.getSelectedItem(); updateSubFamilyMenu(family); stylePanel.add(fontSubFamilyMenu); fontSelectionType = FAMILY_AND_SUBFAMILY; if (!familyAndSubFamilyRBMI.isSelected()) { familyAndSubFamilyRBMI.setSelected(true); } String subname = (String)fontSubFamilyMenu.getSelectedItem(); Font font = FontFamily.getFont(family, subname); currentFontName = (font != null) ? font.getFontName(l) : family; fp.setFontParams(currentFontName, Float.parseFloat(sizeField.getText()), 0, // want to reset style to PLAIN transformMenu.getSelectedIndex()); revalidate(); repaint(); } void setFontSelectionType(int fsType) { switch (fsType) { case FAMILY_AND_STYLE : setUseFamilyAndStyle(); break; case FONT_NAME : setUseFontName(); break; case FAMILY_AND_SUBFAMILY : setUseFamilyAndSubFamily(); break; } } /// 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 = (JMenuItem) source; String itemName = mi.getText(); if (source == familyAndStyleRBMI) { setUseFamilyAndStyle(); } else if (source == familyAndSubFamilyRBMI) { setUseFamilyAndSubFamily(); } else if (source == fontNameRBMI) { setUseFontName(); } else 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.setVisible(true); else if ( itemName.equals( "Close" )) parent.dispose(); else if ( itemName.equals( "Exit" )) System.exit(0); } else if ( source instanceof JTextField ) { JTextField tf = (JTextField) source; 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(currentFontName, sz, styleMenu.getSelectedIndex(), transformMenu.getSelectedIndex() ); } } else if ( source instanceof JButton ) { String itemName = ( (JButton) source ).getText(); /// Print dialog buttons... if ( itemName.equals( "Print" )) { for ( int i = 0; i < printModeCBs.length; i++ ) if ( printModeCBs[i].isSelected() ) { printDialog.setVisible(false); fp.doPrint( i ); } } else if ( itemName.equals( "Cancel" )) printDialog.setVisible(false); /// 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 = (JComboBox) source; /// RangeMenu handles actions by itself and then calls fireRangeChanged, /// so it is not listed or handled here if ( c == fontMenu || c == fontNameMenu || c == fontSubFamilyMenu || c == styleMenu || c == transformMenu ) { if (c == fontNameMenu) { currentFontName = (String)fontNameMenu.getSelectedItem(); } else if ((c == fontMenu) && (fontSelectionType == FAMILY_AND_STYLE)) { currentFontName = (String)fontMenu.getSelectedItem(); } else if ((c == fontMenu) && (fontSelectionType == FAMILY_AND_SUBFAMILY)) { String family = (String)fontMenu.getSelectedItem(); updateSubFamilyMenu(family); String subname = (String)fontSubFamilyMenu.getSelectedItem(); Font font = FontFamily.getFont(family, subname); if (font == null) return; currentFontName = font.getFontName(l); } else if (c == fontSubFamilyMenu) { /* * When switching families, all items are removed from the sub family list. * This triggers a synchronous recursive ActionEvent on the EDT, which should * be ignored here, the code removes them adds the new items and will then * use the new default selected item. * If we do not return, we'll not find a match and can get an NPE. * This feels unsatisfactory, but it works. */ if (fontSubFamilyMenu.getItemCount() == 0) { return; } String family = (String)fontMenu.getSelectedItem(); String subname = (String)fontSubFamilyMenu.getSelectedItem(); Font font = FontFamily.getFont(family, subname); if (font == null) return; currentFontName = font.getFontName(l); } 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(currentFontName, 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 = (JCheckBoxMenuItem) source; if ( cbmi == displayGridCBMI ) fp.setGridDisplay( displayGridCBMI.getState() ); else if ( cbmi == force16ColsCBMI ) fp.setForce16Columns( force16ColsCBMI.getState() ); else if ( cbmi == showFontInfoCBMI ) { if ( showFontInfoCBMI.getState() ) { fireUpdateFontInfo(); fontInfoDialog.setVisible(true); } else fontInfoDialog.setVisible(false); } } } 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); } static class FontFamily { static Map familyMap = new HashMap<>(); private static Locale l = Locale.getDefault(); private List fonts = new ArrayList<>(); private List subFamilyNames = new ArrayList<>(); private Map nameToFontMap = new HashMap<>(); private String familyName; private FontFamily(String name) { this.familyName = name; } String stripFamily(String family, String fullName) { if (family.equals(fullName)) { return ""; } char[] familyChars = family.toCharArray(); char[] fullChars = fullName.toCharArray(); int familyIndex = 0; int fullIndex = 0; // there's probably a clever regexp way to do this // iterate over the chars in the family , if they are the same // keep going, if there's a '-' or ' ', skip it. In the font name, // do the same. If you reach the end of the family without some // other diff, return what's left of the fullName. while (familyIndex < familyChars.length && fullIndex < fullChars.length) { //while (familyIndex < familyChars.length) { if (fullIndex == fullChars.length) { System.err.println("WEIRD FONT " + family + " " + fullName); break; } if (familyChars[familyIndex] == fullChars[fullIndex]) { familyIndex++; fullIndex++; } else if (familyChars[familyIndex] == ' ' && fullChars[fullIndex] == '-') { familyIndex++; fullIndex++; } else if (familyChars[familyIndex] == '-' && fullChars[fullIndex] == ' ') { familyIndex++; fullIndex++; } else if (familyChars[familyIndex] == ' ' || familyChars[familyIndex] == '-') { familyIndex++; } else if (fullChars[fullIndex] == ' ' || fullChars[fullIndex] == '-') { fullIndex++; } else { break; } } if (fullIndex == fullChars.length) { return fullName; } else { return fullName.substring(fullIndex); } } /* * Getting the string to display here can be an art. * If the family is "Arial Black", then for a regular font, the * full name may be "Arial Black", or "Arial-Black", as reported on macOS. * For this case for the specific font might want to display the * full name, or synthesise "Regular". But to do that we have to * recognise that ' ' to '-' mapping. * For "Arial Black Italic" (Arial-Black-Italic) we want to be able to * trim so we display just "Italic". * Then we need to be able to map the text selection back to the * right font. */ void add(Font f) { String fontName = f.getFontName(l); int flen = familyName.length(); int nlen = fontName.length(); String sfn; if (fontName.equals(familyName)) { sfn = "Regular"; } else { sfn = stripFamily(familyName, fontName); sfn = sfn.replace('-', ' '); } fonts.add(f); subFamilyNames.add(sfn); nameToFontMap.put(sfn, f); } String[] getSubFamilyNames() { return subFamilyNames.stream().sorted().toArray(String[]::new); } Font getFontForSubFamilyName(String name) { return nameToFontMap.get(name); } static FontFamily getFontFamily(String name) { return familyMap.get(name); } static FontFamily createFontFamily(String name) { FontFamily f = familyMap.get(name); if (f == null) { f = new FontFamily(name); familyMap.put(name, f); } return f; } /* * familyName must be a name of an existing FontFamily * name, must be a valid "subFamilyName" within that FontFamily * as returned by getSubFamilyNames() */ static Font getFont(String familyName, String subFamilyName) { FontFamily family = getFontFamily(familyName); return family.getFontForSubFamilyName(subFamilyName); } } static String[] familyNames; static Font[] allFonts; static List allFontNames; static Map familyMap = new HashMap<>(); private static void buildFontInfo() { GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment(); familyNames = ge.getAvailableFontFamilyNames(); allFonts = ge.getAllFonts(); allFontNames = new ArrayList(); Locale l = Locale.getDefault(); for (Font f : allFonts) { allFontNames.add(f.getFontName(l)); String family = f.getFamily(l); FontFamily ff = FontFamily.getFontFamily(family); if (ff == null) { ff = FontFamily.createFontFamily(family); } ff.add(f); } } String getFontNameFor(String family, String subFamily) { return family + " " + subFamily; } void updateSubFamilyMenu(String name) { FontFamily family = FontFamily.getFontFamily(name); fontSubFamilyMenu.removeAllItems(); String [] sfNames = family.getSubFamilyNames(); for (int i=0; i 0) { if (argv[0].equalsIgnoreCase("-disablecandisplaycheck") || argv[0].equalsIgnoreCase("-dcdc")) { canDisplayCheck = false; } else { printUsage(); } } buildFontInfo(); try { UIManager.setLookAndFeel(new NimbusLookAndFeel()); SwingUtilities.invokeAndWait(() -> { final JFrame f = new JFrame( "Font2DTest" ); final Font2DTest f2dt = new Font2DTest( f); 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.setVisible(true); }); } catch (UnsupportedLookAndFeelException|InterruptedException|InvocationTargetException e) { } } /// 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, 0, 0, this ); } } /// 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 = (String) this.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) { BufferedImage yes = new BufferedImage(10, 10, BufferedImage.TYPE_INT_ARGB); Graphics2D g = yes.createGraphics(); g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); g.setColor(Color.BLUE); g.drawLine(0, 5, 3, 10); g.drawLine(1, 5, 4, 10); g.drawLine(3, 10, 10, 0); g.drawLine(4, 9, 9, 0); g.dispose(); BufferedImage blank = new BufferedImage(10, 10, BufferedImage.TYPE_INT_ARGB); yesImage = new ImageIcon(yes); blankImage = new ImageIcon(blank); 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 ); } } }