In this chapter:

• Word Processor: part I - Introducing RTF
• Word Processor: part II - Managing fonts
• Word Processor: part III - Colors and images
• Word Processor: part IV - Working with styles
• Word Processor: part V - Clipboard and undo/redo
• Word Processor: part VI - Advanced font mangement
• Word Processor: part VII - Paragraph formatting
• Word Processor: part VIII - Find and replace
• Word Processor: part IX - Spell checker [using JDBC and SQL]

This chapter is devoted to the construction of a fully-functional RTF word processor application. Though Swing’s HTML and RTF capabilities are very powerful, they are not yet complete. RTF support is further along than HTML, and this is why we chose to design our word processor for use with RTF documents. The examples in this chapter demonstrate practical applications of many of the topics covered in chapter 19. The main focus throughout is working with styled text documents, and the techniques discussed here can be applied to any styled text editor.

<<file figure20-1.gif>>

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;

import javax.swing.*;
import javax.swing.text.*;
import javax.swing.event.*;
import javax.swing.border.*;
import javax.swing.text.rtf.*;

public class WordProcessor extends JFrame 
{
  protected JTextPane m_monitor;
  protected StyleContext m_context; 
  protected DefaultStyledDocument m_doc;
  protected RTFEditorKit m_kit;
  protected JFileChooser m_chooser;
  protected SimpleFilter m_rtfFilter;
  protected JToolBar m_toolBar;

  public WordProcessor() {
    super("RTF Word Processor");
    setSize(600, 400);

    // Make sure we install the editor kit before creating
    // the initial document.
    m_monitor = new JTextPane();
    m_kit = new RTFEditorKit();
    m_monitor.setEditorKit(m_kit);
    m_context = new StyleContext();
    m_doc = new DefaultStyledDocument(m_context);
    m_monitor.setDocument(m_doc);

    JScrollPane ps = new JScrollPane(m_monitor);
    getContentPane().add(ps, BorderLayout.CENTER);

    JMenuBar menuBar = createMenuBar();
    setJMenuBar(menuBar);

    m_chooser = new JFileChooser(); 
    m_chooser.setCurrentDirectory(new File("."));
    m_rtfFilter = new SimpleFilter("rtf", "RTF Documents");
    m_chooser.setFileFilter(m_rtfFilter);

    WindowListener wndCloser = new WindowAdapter() {
      public void windowClosing(WindowEvent e) {
        System.exit(0);
      }
    };
    addWindowListener(wndCloser);
        
    setVisible(true);
  }

  protected JMenuBar createMenuBar() {
    JMenuBar menuBar = new JMenuBar();
        
    JMenu mFile = new JMenu("File");
    mFile.setMnemonic('f');

    ImageIcon iconNew = new ImageIcon("file_new.gif");
    Action actionNew = new AbstractAction("New", iconNew) { 
      public void actionPerformed(ActionEvent e) {
        m_doc = new DefaultStyledDocument(m_context);
        m_monitor.setDocument(m_doc);
      }
    };
    JMenuItem item =  mFile.add(actionNew);  
    item.setMnemonic('n');

    ImageIcon iconOpen = new ImageIcon("file_open.gif");
    Action actionOpen = new AbstractAction("Open...", iconOpen) { 
      public void actionPerformed(ActionEvent e) {
        WordProcessor.this.setCursor(
          Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
        Thread runner = new Thread() {
          public void run() {
            if (m_chooser.showOpenDialog(WordProcessor.this) != 
             JFileChooser.APPROVE_OPTION)
              return;
            WordProcessor.this.repaint();
            File fChoosen = m_chooser.getSelectedFile();

            // Recall that text component read/write operations are 
            // thread safe. Its ok to do this in a separate thread.
            try {
              InputStream in = new FileInputStream(fChoosen);
              m_doc = new DefaultStyledDocument(m_context);
              m_kit.read(in, m_doc, 0);
              m_monitor.setDocument(m_doc);
              in.close();
            } 
            catch (Exception ex) {
              ex.printStackTrace();
            }
            WordProcessor.this.setCursor(Cursor.getPredefinedCursor(
              Cursor.DEFAULT_CURSOR));
          }
        };
        runner.start();
      }
    };
    item =  mFile.add(actionOpen);  
    item.setMnemonic('o');

    ImageIcon iconSave = new ImageIcon("file_save.gif");
    Action actionSave = new AbstractAction("Save...", iconSave) {
      public void actionPerformed(ActionEvent e) {
        WordProcessor.this.setCursor(
          Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
        Thread runner = new Thread() {
          public void run() {
            if (m_chooser.showSaveDialog(WordProcessor.this) !=
             JFileChooser.APPROVE_OPTION)
              return;
            WordProcessor.this.repaint();
            File fChoosen = m_chooser.getSelectedFile();

            // Recall that text component read/write operations are
            // thread safe. Its ok to do this in a separate thread.
            try {
              OutputStream out = new FileOutputStream(fChoosen);
              m_kit.write(out, m_doc, 0, m_doc.getLength());
              out.close();
            } 
            catch (Exception ex) {
              ex.printStackTrace();
            }
           
            // Make sure chooser is updated to reflect new file
            m_chooser.rescanCurrentDirectory();
            WordProcessor.this.setCursor(Cursor.getPredefinedCursor(
              Cursor.DEFAULT_CURSOR));
          }
        };
        runner.start();
      }
    };
    item = mFile.add(actionSave);  
    item.setMnemonic('s');

    mFile.addSeparator();

    Action actionExit = new AbstractAction("Exit") { 
      public void actionPerformed(ActionEvent e) {
        System.exit(0);
      }
    };

    item =  mFile.add(actionExit);  
    item.setMnemonic('x');
    menuBar.add(mFile);

    m_toolBar = new JToolBar();
    JButton bNew = new SmallButton(actionNew, "New document");
    m_toolBar.add(bNew);

    JButton bOpen = new SmallButton(actionOpen, "Open RTF document");
    m_toolBar.add(bOpen);
        
    JButton bSave = new SmallButton(actionSave, "Save RTF document");
    m_toolBar.add(bSave);
    
    getContentPane().add(m_toolBar, BorderLayout.NORTH);
       
    return menuBar;
  }

  public static void main(String argv[]) {
    new WordProcessor();
  }
}

The following example adds the ability to select any font available on the system. This functionality is similar to the "Font" menu used in the examples of chapter 12. The important difference here is that the selected font applies not to the whole text component (the only possible thing with plain text documents), but to the selected region of our RTF styled document text.

<<file figure20-1.gif>>

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;

import javax.swing.*;
import javax.swing.text.*;
import javax.swing.event.*;
import javax.swing.border.*;
import javax.swing.text.rtf.*;

public class WordProcessor extends JFrame 
{
  protected JTextPane m_monitor;
  protected StyleContext m_context; 
  protected DefaultStyledDocument m_doc;
  protected RTFEditorKit m_kit;
  protected JFileChooser m_chooser;
  protected SimpleFilter m_rtfFilter;
  protected JToolBar m_toolBar;

  protected JComboBox m_cbFonts;
  protected JComboBox m_cbSizes;
  protected SmallToggleButton m_bBold;
  protected SmallToggleButton m_bItalic;

  protected String m_fontName = "";
  protected int m_fontSize = 0;
  protected boolean m_skipUpdate;

  protected int m_xStart = -1;
  protected int m_xFinish = -1;

  public WordProcessor() {

    // Unchanged code from section 20.1

    CaretListener lst = new CaretListener() {
      public void caretUpdate(CaretEvent e) {
        showAttributes(e.getDot());
      }
    };
    m_monitor.addCaretListener(lst);

    FocusListener flst = new FocusListener() { 
      public void focusGained(FocusEvent e) {
        if (m_xStart>=0 && m_xFinish>=0)
          if (m_monitor.getCaretPosition()==m_xStart) {
            m_monitor.setCaretPosition(m_xFinish);
            m_monitor.moveCaretPosition(m_xStart);
          }
          else
            m_monitor.select(m_xStart, m_xFinish);
      }

      public void focusLost(FocusEvent e) {
        m_xStart = m_monitor.getSelectionStart();
        m_xFinish = m_monitor.getSelectionEnd();
      }
    };
    m_monitor.addFocusListener(flst);

    WindowListener wndCloser = new WindowAdapter() {
      public void windowClosing(WindowEvent e) {
        System.exit(0);
      }
    };
    addWindowListener(wndCloser);
        
    showAttributes(0);
    setVisible(true);
  }

  protected JMenuBar createMenuBar() {

    // Unchaged code from section 20.1
 
    // The following line is added to the end of the
    // actionNew and actionOpen actionPerformed() methods:
    // 
    //   showAttributes(0);
    //
    // (see source code; these methods are not shown here
    //  to conserve space)

    // Unchaged code from section 20.1

    GraphicsEnvironment ge = GraphicsEnvironment.
      getLocalGraphicsEnvironment();
    String[] fontNames = ge.getAvailableFontFamilyNames();

    m_toolBar.addSeparator();
    m_cbFonts = new JComboBox(fontNames);
    m_cbFonts.setMaximumSize(m_cbFonts.getPreferredSize());
    m_cbFonts.setEditable(true);

    ActionListener lst = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        m_fontName = m_cbFonts.getSelectedItem().toString();
        MutableAttributeSet attr = new SimpleAttributeSet();
        StyleConstants.setFontFamily(attr, m_fontName);
        setAttributeSet(attr);
        m_monitor.grabFocus();
      }
    };
    m_cbFonts.addActionListener(lst);
    m_toolBar.add(m_cbFonts);

    m_toolBar.addSeparator();
    m_cbSizes = new JComboBox(new String[] {"8", "9", "10", 
      "11", "12", "14", "16", "18", "20", "22", "24", "26", 
      "28", "36", "48", "72"});
    m_cbSizes.setMaximumSize(m_cbSizes.getPreferredSize());
    m_cbSizes.setEditable(true);

    lst = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        int fontSize = 0;
        try {
          fontSize = Integer.parseInt(m_cbSizes.
            getSelectedItem().toString());
        }
        catch (NumberFormatException ex) { return; }

        m_fontSize = fontSize;
        MutableAttributeSet attr = new SimpleAttributeSet();
        StyleConstants.setFontSize(attr, fontSize);
        setAttributeSet(attr);
        m_monitor.grabFocus();
      }
    };
    m_cbSizes.addActionListener(lst);
    m_toolBar.add(m_cbSizes);

    m_toolBar.addSeparator();
    ImageIcon img1 = new ImageIcon("font_bold1.gif");
    ImageIcon img2 = new ImageIcon("font_bold2.gif");
    m_bBold = new SmallToggleButton(false, img1, img2, 
      "Bold font");
    lst = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        MutableAttributeSet attr = new SimpleAttributeSet();
        StyleConstants.setBold(attr, m_bBold.isSelected());
        setAttributeSet(attr);
        m_monitor.grabFocus();
      }
    };
    m_bBold.addActionListener(lst);
    m_toolBar.add(m_bBold);
        
    img1 = new ImageIcon("font_italic1.gif");
    img2 = new ImageIcon("font_italic2.gif");
    m_bItalic = new SmallToggleButton(false, img1, img2, 
      "Italic font");
    lst = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        MutableAttributeSet attr = new SimpleAttributeSet();
        StyleConstants.setItalic(attr, m_bItalic.isSelected());
        setAttributeSet(attr);
        m_monitor.grabFocus();
      }
    };
    m_bItalic.addActionListener(lst);
    m_toolBar.add(m_bItalic);

    getContentPane().add(m_toolBar, BorderLayout.NORTH);        

    return menuBar;
  }

  protected void showAttributes(int p) {
    m_skipUpdate = true;
    AttributeSet a = m_doc.getCharacterElement(p).
      getAttributes();
    String name = StyleConstants.getFontFamily(a);
    if (!m_fontName.equals(name)) {
      m_fontName = name;
      m_cbFonts.setSelectedItem(name);
    }
    int size = StyleConstants.getFontSize(a);
    if (m_fontSize != size) {
      m_fontSize = size;
      m_cbSizes.setSelectedItem(Integer.toString(m_fontSize));
    }
    boolean bold = StyleConstants.isBold(a);
    if (bold != m_bBold.isSelected())
      m_bBold.setSelected(bold);
    boolean italic = StyleConstants.isItalic(a);
    if (italic != m_bItalic.isSelected())
      m_bItalic.setSelected(italic);
    m_skipUpdate = false;
  }

  protected void setAttributeSet(AttributeSet attr) {
    if (m_skipUpdate)
      return;
    int xStart = m_monitor.getSelectionStart();
    int xFinish = m_monitor.getSelectionEnd();
    if (!m_monitor.hasFocus()) {
      xStart = m_xStart;
      xFinish = m_xFinish;
    }
    if (xStart != xFinish) {
      m_doc.setCharacterAttributes(xStart, xFinish - xStart, 
        attr, false);
    } 
    else {
      MutableAttributeSet inputAttributes = 
        m_kit.getInputAttributes();
      inputAttributes.addAttributes(attr);
    }
  }

  public static void main(String argv[]) {
        new WordProcessor();
  }
}

// Unchanged code from section 20.1

// Class SmallToggleButton unchanged from section 12.4

Several new instance variables have been added:

Open an existing RTF file and move the cursor to various positions in the text. Note that the text attributes displayed in the toolbar components are updated correctly. Select a portion of text and use the toolbar components to modify the selection’s font attributes. Type a new font name or font size in the editable combobox and press "Enter." This has the same effect as selecting a choice from the drop-down list. Save the RTF file and open it in another RTF-aware application to verify that your changes were saved correctly.

Important RTF features we will exploit in this section include the ability to use foreground and background colors and insert images into the text. In this example we show how to add these capabilities to our growing RTF word processor application.

<<file figure20-3.gif>>

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;

import javax.swing.*;
import javax.swing.text.*;
import javax.swing.event.*;
import javax.swing.border.*;
import javax.swing.text.rtf.*;

public class WordProcessor extends JFrame 
{
  // Unchanged code from section 20.2

  protected SimpleFilter m_jpgFilter;
  protected SimpleFilter m_gifFilter;

  protected ColorMenu m_foreground;
  protected ColorMenu m_background;

  public WordProcessor() {

    // Unchanged code from section 20.2

    m_chooser = new JFileChooser(); 
    m_chooser.setCurrentDirectory(new File("."));
    m_rtfFilter = new SimpleFilter("rtf", "RTF Documents");
    m_chooser.setFileFilter(m_rtfFilter);

    m_gifFilter = new SimpleFilter("gif", "GIF images");
    m_jpgFilter = new SimpleFilter("jpg", "JPG images");
 
    // Unchanged code from section 20.2       
  }

  protected JMenuBar createMenuBar() {

    // Unchanged code from section 20.2

    JMenu mFormat = new JMenu("Format");
    mFormat.setMnemonic('o');

    m_foreground = new ColorMenu("Foreground");
    m_foreground.setColor(m_monitor.getForeground());
    m_foreground.setMnemonic('f');
    lst = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        MutableAttributeSet attr = new SimpleAttributeSet();
        StyleConstants.setForeground(attr, m_foreground.getColor());
        setAttributeSet(attr);
      }
    };
    m_foreground.addActionListener(lst);
    mFormat.add(m_foreground);

    MenuListener ml = new MenuListener() {
      public void menuSelected(MenuEvent e) {
        int p = m_monitor.getCaretPosition();
        AttributeSet a = m_doc.getCharacterElement(p).
          getAttributes();
        Color c = StyleConstants.getForeground(a);
        m_foreground.setColor(c);
      }

      public void menuDeselected(MenuEvent e) {}

      public void menuCanceled(MenuEvent e) {}
    };
    m_foreground.addMenuListener(ml);

    // Bug Alert! JEditorPane background color 
    // doesn't work as of Java 2 FCS.
    m_background = new ColorMenu("Background");
    m_background.setColor(m_monitor.getBackground());
    m_background.setMnemonic('b');
    lst = new ActionListener()  { 
      public void actionPerformed(ActionEvent e) {
        MutableAttributeSet attr = new SimpleAttributeSet();
        StyleConstants.setBackground(attr, m_background.getColor());
        setAttributeSet(attr);
      }
    };
    m_background.addActionListener(lst);
    mFormat.add(m_background);

    ml = new MenuListener() {
      public void menuSelected(MenuEvent e) {
        int p = m_monitor.getCaretPosition();
        AttributeSet a = m_doc.getCharacterElement(p).
          getAttributes();
        Color c = StyleConstants.getBackground(a);
        m_background.setColor(c);
      }

      public void menuDeselected(MenuEvent e) {}

      public void menuCanceled(MenuEvent e) {}
    };
    m_background.addMenuListener(ml);

    // Bug Alert! Images do not get saved.
    mFormat.addSeparator();
    item = new JMenuItem("Insert Image");  
    item.setMnemonic('i');
    lst = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        m_chooser.addChoosableFileFilter(m_gifFilter);
        m_chooser.addChoosableFileFilter(m_jpgFilter);
        m_chooser.setFileFilter(m_gifFilter);
        m_chooser.removeChoosableFileFilter(m_rtfFilter);
        Thread runner = new Thread() {
          public void run() {
            if (m_chooser.showOpenDialog(WordProcessor.this) != 
            JFileChooser.APPROVE_OPTION)
              return;
            WordProcessor.this.repaint();
            File fChoosen = m_chooser.getSelectedFile();
            ImageIcon icon = new ImageIcon(fChoosen.getPath());
            int w = icon.getIconWidth();
            int h = icon.getIconHeight();
            if (w<=0 || h<=0) {
              JOptionPane.showMessageDialog(WordProcessor.this, 
                "Error reading image file\n"+
                fChoosen.getPath(), "Warning", 
                JOptionPane.WARNING_MESSAGE);
                return;
            }
            MutableAttributeSet attr = new SimpleAttributeSet();
            StyleConstants.setIcon(attr, icon);
            int p = m_monitor.getCaretPosition();
            try {
              m_doc.insertString(p, " ", attr);
            }
            catch (BadLocationException ex) {}
    
            // Its ok to do this outside of the event-dispatching
            // thread because the chooser is not visible here.
            m_chooser.addChoosableFileFilter(m_rtfFilter);
            m_chooser.setFileFilter(m_rtfFilter);
            m_chooser.removeChoosableFileFilter(m_gifFilter);
            m_chooser.removeChoosableFileFilter(m_jpgFilter);
          }
        };
        runner.start();
      }
    };
    item.addActionListener(lst);
    mFormat.add(item);

    menuBar.add(mFormat);

    getContentPane().add(m_toolBar, BorderLayout.NORTH);   
 
    return menuBar;
  }

  // Unchanged code from section 20.2
}

// Unchanged code from section 20.2

// Class ColorMenu unchanged from section 12.5

Four new instance variables have been added:

Open an existing RTF file, select a portion of text and use the custom color menu component to modify it's foreground. Save the RTF file and open it in another RTF-aware application to verify that your changes have been saved correctly. Try using the "Insert Image" menu to bring up a file chooser and select an image for insertion.

Using Styles to manage a set of attributes as a single named entity can greatly simplify text editing. The user only has to apply a known style to a selected region of text rather than selecting all appropriate text attributes from the provided toolbar components. By adding a combo box allowing the choice of styles, we can not only save the user time and effort, but we can also provide more uniform text formatting throughout the resulting document (or potentially set of documents). In this section we'll add style management to our word processor. We’ll also show how it is possible to create a new style, modify an existing style, or reapply a style to modified text.

<<file figure20-4.gif>>

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;

import javax.swing.*;
import javax.swing.text.*;
import javax.swing.event.*;
import javax.swing.border.*;
import javax.swing.text.rtf.*;

public class WordProcessor extends JFrame 
{
  // Unchanged code from section 20.3

  protected JComboBox m_cbStyles;

  public WordProcessor() {
    // Unchanged code from section 20.3

    showAttributes(0);
    showStyles();
    setVisible(true);
  }

  protected JMenuBar createMenuBar() {
    // Unchanged code from section 20.3

    // The following line is added to the end of the
    // actionNew and actionOpen actionPerformed() methods:
    // 
    //   showStyles();
    //
    // (see source code; these methods are not shown here
    //  to conserve space)
        
    // Unchanged code from section 20.3

    JMenu mFormat = new JMenu("Format");
    mFormat.setMnemonic('o');

    JMenu mStyle = new JMenu("Style");
    mStyle.setMnemonic('s');
    mFormat.add(mStyle);

    item = new JMenuItem("Update");
    item.setMnemonic('u');
    lst = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        String name = (String)m_cbStyles.getSelectedItem();
        Style style = m_doc.getStyle(name);
        int p = m_monitor.getCaretPosition();
        AttributeSet a = m_doc.getCharacterElement(p).
          getAttributes();
        style.addAttributes(a);
        m_monitor.repaint();
      }
    };
    item.addActionListener(lst);
    mStyle.add(item);

    item = new JMenuItem("Reapply");
    item.setMnemonic('r');
    lst = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        String name = (String)m_cbStyles.getSelectedItem();
        Style style = m_doc.getStyle(name);
        setAttributeSet(style);
      }
    };
    item.addActionListener(lst);
    mStyle.add(item);

    mFormat.addSeparator();

    // Unchanged code from section 20.3

    menuBar.add(mFormat);

    m_toolBar.addSeparator();
    m_cbStyles = new JComboBox();
    m_cbStyles.setMaximumSize(m_cbStyles.getPreferredSize());
    m_cbStyles.setEditable(true);
    m_toolBar.add(m_cbStyles);
        
    lst = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        if (m_skipUpdate || m_cbStyles.getItemCount()==0)
          return;
        String name = (String)m_cbStyles.getSelectedItem();
        int index = m_cbStyles.getSelectedIndex();
        int p = m_monitor.getCaretPosition();
                
        // New name entered
        if (index == -1) {
          m_cbStyles.addItem(name);
          Style style = m_doc.addStyle(name, null);
          AttributeSet a = m_doc.getCharacterElement(p).
            getAttributes();
          style.addAttributes(a);
          return;
        }

        // Apply the selected style
        Style currStyle = m_doc.getLogicalStyle(p);
        if (!currStyle.getName().equals(name)) {
          Style style = m_doc.getStyle(name);
          setAttributeSet(style);
        }
      }
    };
    m_cbStyles.addActionListener(lst);
        
    getContentPane().add(m_toolBar, BorderLayout.NORTH);

    return menuBar;
  }

  protected void showAttributes(int p) {
    // Unchanged code from section 20.2

    Style style = m_doc.getLogicalStyle(p);
    name = style.getName();
    m_cbStyles.setSelectedItem(name);

    m_skipUpdate = false;
  }

  // Unchanged code from section 20.3

  protected void showStyles() {
    m_skipUpdate = true;
    if (m_cbStyles.getItemCount() > 0)
      m_cbStyles.removeAllItems();
    Enumeration en = m_doc.getStyleNames();
    while (en.hasMoreElements()) {
      String str = en.nextElement().toString();
      m_cbStyles.addItem(str);
    }
    m_skipUpdate = false;
  }

  public static void main(String argv[]) {
    new WordProcessor();
  }
}

// Unchanged code from section 20.3

One new instance variable has been added:

An ambiguous situation occurs when the user selects a style for text which already has the same style, but whose attributes have been modified. The user may either want to update the selected style using the selected text as a base, or reapply the existing style to the selected text. To resolve this situation we need to ask the user what to do. We chose to add two menu items which allow the user to either update or reapply the current selection.

Open an existing RTF file, and note how the styles combobox is populated by the style names defined in this document. Verify that the selected style is automatically updated while the caret moves through the document. Select a portion of text and select a different style from the styles combobox. Note how all text properties are updated according to the new style.

Try selecting a portion of text and modifying its attributes (for instance, foreground color). Type a new name in the styles combobox and press Enter. This will create a new style which can be applied to any other document text.

Try modifying an attribute of a selected region of text (e.g. the font size) and select the "Style|Update" menu item. This will update the style to incorporate the newly selected attributes. Apply the modified style to another portion of text and verify that it applies according to the updated style.

Now try modifying some attributes of a portion of selected text and then select the "Style|Reapply" menu item. This will restore the original text attributes associated with the appropriate style.

Clipboard and undo/redo operations have become common and necessary components of all modern text editing environments. We have discussed these features in chapters 11 and 19, and in this section we show how to integrate them into our RTF word processor.

<<file figure20-5.gif>>

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;

import javax.swing.*;
import javax.swing.text.*;
import javax.swing.event.*;
import javax.swing.border.*;
import javax.swing.text.rtf.*;
import javax.swing.undo.*;

public class WordProcessor extends JFrame 
{>    
  // Unchanged code from section 20.4

  protected UndoManager m_undo = new UndoManager();
  protected Action m_undoAction;
  protected Action m_redoAction;

  public WordProcessor() {
    // Unchanged code from section 20.4

    showAttributes(0);
    showStyles();
    m_doc.addUndoableEditListener(new Undoer());
    setVisible(true);
  }

  protected JMenuBar createMenuBar() {
    // The following line is added to the end of the
    // actionNew and actionOpen actionPerformed() methods:
    // 
    //   m_doc.addUndoableEditListener(new Undoer());
    //
    // (see source code; these methods are not shown here
    //  to conserve space)
        
    // Unchanged code from section 20.4

    JButton bSave = new SmallButton(actionSave, "Save RTF document");
    m_toolBar.add(bSave);

    JMenu mEdit = new JMenu("Edit");
    mEdit.setMnemonic('e');

    Action action = new AbstractAction("Copy", 
     new ImageIcon("edit_copy.gif")) 
    { 
      public void actionPerformed(ActionEvent e) {
        m_monitor.copy();
      }
    };
    item = mEdit.add(action);  
    item.setMnemonic('c');
    item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_C, 
      KeyEvent.CTRL_MASK));

    action = new AbstractAction("Cut", 
     new ImageIcon("edit_cut.gif")) 
    { 
      public void actionPerformed(ActionEvent e) {
        m_monitor.cut();
      }
    };
    item = mEdit.add(action);  
    item.setMnemonic('t');
    item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_X, 
      KeyEvent.CTRL_MASK));

    action = new AbstractAction("Paste", 
     new ImageIcon("edit_paste.gif")) 
    { 
      public void actionPerformed(ActionEvent e) {
        m_monitor.paste();
      }
    };
    item = mEdit.add(action);  
    item.setMnemonic('p');
    item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_V, 
      KeyEvent.CTRL_MASK));

    mEdit.addSeparator();

    m_undoAction = new AbstractAction("Undo", 
     new ImageIcon("edit_undo.gif")) 
    { 
      public void actionPerformed(ActionEvent e) {
        try {
          m_undo.undo();
        } 
        catch (CannotUndoException ex) {
          System.err.println("Unable to undo: " + ex);
        }
        updateUndo();
      }
    };
    item = mEdit.add(m_undoAction);  
    item.setMnemonic('u');
    item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Z, 
      KeyEvent.CTRL_MASK));

    m_redoAction = new AbstractAction("Redo", 
     new ImageIcon("edit_redo.gif")) 
    { 
      public void actionPerformed(ActionEvent e) {
        try {
          m_undo.redo();
        } 
        catch (CannotRedoException ex) {
          System.err.println("Unable to redo: " + ex);
        }
        updateUndo();
      }
    };
    item =  mEdit.add(m_redoAction);  
    item.setMnemonic('r');
    item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Y, 
      KeyEvent.CTRL_MASK));

    menuBar.add(mEdit);

    GraphicsEnvironment ge = GraphicsEnvironment.
      getLocalGraphicsEnvironment();
    String[] fontNames = ge.getAvailableFontFamilyNames();

    // Unchanged code from section 20.4

    return menuBar;
  }

  // Unchanged code from section 20.4

  protected void updateUndo() {
    if(m_undo.canUndo()) {
      m_undoAction.setEnabled(true);
      m_undoAction.putValue(Action.NAME, 
      m_undo.getUndoPresentationName());
    }
    else {
      m_undoAction.setEnabled(false);
      m_undoAction.putValue(Action.NAME, "Undo");
    }
    if(m_undo.canRedo()) {
      m_redoAction.setEnabled(true);
      m_redoAction.putValue(Action.NAME, 
      m_undo.getRedoPresentationName());
    }
    else {
      m_redoAction.setEnabled(false);
      m_redoAction.putValue(Action.NAME, "Redo");
    }
  }

  public static void main(String argv[]) {
    new WordProcessor();
  }

  class Undoer implements UndoableEditListener
  {
    public Undoer() {
      m_undo.die();
      updateUndo();
    }

    public void undoableEditHappened(UndoableEditEvent e) {
      UndoableEdit edit = e.getEdit();
      m_undo.addEdit(e.getEdit());
      updateUndo();
    }
  }
}

// Unchanged code from section 20.4

Open an existing RTF file and verify that copy, cut, and paste clipboard operations transfer plain text successfully. Make some changes to the textual content or styles and note that the title of the "Undo" menu item is updated. Select this menu item, or press its keyboard accelerator (Ctrl-Z) to undo a series of changes. This will enable the "Redo" menu item. Use this menu item or press its keyboard accelerator (Ctrl-Y) to redo a series of changes.

In section 20.2 we used toolbar components to change manipulate font properties. This is useful for making a quick modification without leaving the main application frame, and is typical for word processor applications. However, all serious editor applications also provide a dialog for the editing of all available font properties from one location. In the following example we'll show how to create such a dialog, which includes components to select various font properties and preview the result.

<<file figure20-6.gif>>

<<file figure20-7.gif>>

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;

import javax.swing.*;
import javax.swing.text.*;
import javax.swing.event.*;
import javax.swing.border.*;
import javax.swing.text.rtf.*;
import javax.swing.undo.*;

public class WordProcessor extends JFrame 
{
  // Unchanged code from section 20.5

  protected String[] m_fontNames;
  protected String[] m_fontSizes;

  protected FontDialog m_fontDialog;

  protected JMenuBar createMenuBar() {

    // Unchanged code from section 20.5

    GraphicsEnvironment ge = GraphicsEnvironment.
      getLocalGraphicsEnvironment();
    m_fontNames = ge.getAvailableFontFamilyNames();

    m_toolBar.addSeparator();
    m_cbFonts = new JComboBox(m_fontNames);
    m_cbFonts.setMaximumSize(m_cbFonts.getPreferredSize());
    m_cbFonts.setEditable(true);

    // Unchanged code from section 20.5

    m_toolBar.addSeparator();
    m_fontSizes = new String[] {"8", "9", "10", "11", "12", "14",
      "16", "18", "20", "22", "24", "26", "28", "36", "48", "72"};
    m_cbSizes = new JComboBox(m_fontSizes);
    m_cbSizes.setMaximumSize(m_cbSizes.getPreferredSize());
    m_cbSizes.setEditable(true);

    m_fontDialog = new FontDialog(this, m_fontNames, m_fontSizes);

    // Unchanged code from section 20.5

    JMenu mFormat = new JMenu("Format");
    mFormat.setMnemonic('o');

    item = new JMenuItem("Font...");
    item.setMnemonic('o');
    lst = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        WordProcessor.this.repaint();
        AttributeSet a = m_doc.getCharacterElement(
          m_monitor.getCaretPosition()).getAttributes();
        m_fontDialog.setAttributes(a);

        Dimension d1 = m_fontDialog.getSize();
        Dimension d2 = WordProcessor.this.getSize();
        int x = Math.max((d2.width-d1.width)/2, 0);
        int y = Math.max((d2.height-d1.height)/2, 0);
        m_fontDialog.setBounds(x + WordProcessor.this.getX(),
          y + WordProcessor.this.getY(), d1.width, d1.height);

        m_fontDialog.show();
        if (m_fontDialog.getOption()==JOptionPane.OK_OPTION) {
          setAttributeSet(m_fontDialog.getAttributes());
          showAttributes(m_monitor.getCaretPosition());
        }
      }
    };
    item.addActionListener(lst);
    mFormat.add(item);

    mFormat.addSeparator();

    // Unchanged code from section 20.5
     
    return menuBar;
  }

  // Unchanged code from section 20.5
}

 // Unchanged code from section 20.5

class FontDialog extends JDialog
{
  protected int m_option = JOptionPane.CLOSED_OPTION;
  protected OpenList m_lstFontName;
  protected OpenList m_lstFontSize;
  protected MutableAttributeSet m_attributes;
  protected JCheckBox m_chkBold;
  protected JCheckBox m_chkItalic;
  protected JCheckBox m_chkUnderline;
    
  protected JCheckBox m_chkStrikethrough;
  protected JCheckBox m_chkSubscript;
  protected JCheckBox m_chkSuperscript;
    
  protected JComboBox m_cbColor;
  protected JLabel m_preview;

  public FontDialog(JFrame parent, 
    String[] names, String[] sizes)
  {
    super(parent, "Font", true);
    getContentPane().setLayout(new BoxLayout(getContentPane(), 
      BoxLayout.Y_AXIS));

    JPanel p = new JPanel(new GridLayout(1, 2, 10, 2));
    p.setBorder(new TitledBorder(new EtchedBorder(), "Font"));
    m_lstFontName = new OpenList(names, "Name:");
    p.add(m_lstFontName);

    m_lstFontSize = new OpenList(sizes, "Size:");
    p.add(m_lstFontSize);
    getContentPane().add(p);

    p = new JPanel(new GridLayout(2, 3, 10, 5));
    p.setBorder(new TitledBorder(new EtchedBorder(), "Effects"));
    m_chkBold = new JCheckBox("Bold");
    p.add(m_chkBold);
    m_chkItalic = new JCheckBox("Italic");
    p.add(m_chkItalic);
    m_chkUnderline = new JCheckBox("Underline");
    p.add(m_chkUnderline);
    m_chkStrikethrough = new JCheckBox("Strikeout");
    p.add(m_chkStrikethrough);
    m_chkSubscript = new JCheckBox("Subscript");
    p.add(m_chkSubscript);
    m_chkSuperscript = new JCheckBox("Superscript");
    p.add(m_chkSuperscript);
    getContentPane().add(p);

    getContentPane().add(Box.createVerticalStrut(5));
    p = new JPanel();
    p.setLayout(new BoxLayout(p, BoxLayout.X_AXIS));
    p.add(Box.createHorizontalStrut(10));
    p.add(new JLabel("Color:"));
    p.add(Box.createHorizontalStrut(20));
    m_cbColor = new JComboBox();

    int[] values = new int[] { 0, 128, 192, 255 };
    for (int r=0; r<values.length; r++) {
      for (int g=0; g<values.length; g++) {
        for (int b=0; b<values.length; b++) {
          Color c = new Color(values[r], values[g], values[b]);
          m_cbColor.addItem(c);
        }
      }
    }

    m_cbColor.setRenderer(new ColorComboRenderer());
    p.add(m_cbColor);
    p.add(Box.createHorizontalStrut(10));
    getContentPane().add(p);

    p = new JPanel(new BorderLayout());
    p.setBorder(new TitledBorder(new EtchedBorder(), "Preview"));
    m_preview = new JLabel("Preview Font", JLabel.CENTER);
    m_preview.setBackground(Color.white);
    m_preview.setForeground(Color.black);
    m_preview.setOpaque(true);
    m_preview.setBorder(new LineBorder(Color.black));
    m_preview.setPreferredSize(new Dimension(120, 40));
    p.add(m_preview, BorderLayout.CENTER);
    getContentPane().add(p);

    p = new JPanel(new FlowLayout());
    JPanel p1 = new JPanel(new GridLayout(1, 2, 10, 2));
    JButton btOK = new JButton("OK");
    ActionListener lst = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        m_option = JOptionPane.OK_OPTION;
        setVisible(false);
      }
    };
    btOK.addActionListener(lst);
    p1.add(btOK);

    JButton btCancel = new JButton("Cancel");
    lst = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        m_option = JOptionPane.CANCEL_OPTION;
        setVisible(false);
      }
    };
    btCancel.addActionListener(lst);
    p1.add(btCancel);
    p.add(p1);
    getContentPane().add(p);

    pack();
    setResizable(false);
    Dimension d1 = getSize();
    Dimension d2 = parent.getSize();
    int x = Math.max((d2.width-d1.width)/2, 0);
    int y = Math.max((d2.height-d1.height)/2, 0);
    setBounds(x, y, d1.width, d1.height);

    ListSelectionListener lsel = new ListSelectionListener() {
      public void valueChanged(ListSelectionEvent e) {
        updatePreview();
      }
    };
    m_lstFontName.addListSelectionListener(lsel);
    m_lstFontSize.addListSelectionListener(lsel);

    lst = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        updatePreview();
      }
    };
    m_chkBold.addActionListener(lst);
    m_chkItalic.addActionListener(lst);
    m_cbColor.addActionListener(lst);
  }

  public void setAttributes(AttributeSet a) {
    m_attributes = new SimpleAttributeSet(a);
    String name = StyleConstants.getFontFamily(a);
    m_lstFontName.setSelected(name);
    int size = StyleConstants.getFontSize(a);
    m_lstFontSize.setSelectedInt(size);
    m_chkBold.setSelected(StyleConstants.isBold(a));
    m_chkItalic.setSelected(StyleConstants.isItalic(a));
    m_chkUnderline.setSelected(StyleConstants.isUnderline(a));
    m_chkStrikethrough.setSelected(
      StyleConstants.isStrikeThrough(a));
    m_chkSubscript.setSelected(StyleConstants.isSubscript(a));
    m_chkSuperscript.setSelected(StyleConstants.isSuperscript(a));
    m_cbColor.setSelectedItem(StyleConstants.getForeground(a));
    updatePreview();
  }

  public AttributeSet getAttributes() {
    if (m_attributes == null)
      return null;
    StyleConstants.setFontFamily(m_attributes, 
      m_lstFontName.getSelected());
    StyleConstants.setFontSize(m_attributes, 
      m_lstFontSize.getSelectedInt());
    StyleConstants.setBold(m_attributes, 
      m_chkBold.isSelected());
    StyleConstants.setItalic(m_attributes, 
      m_chkItalic.isSelected());
    StyleConstants.setUnderline(m_attributes, 
      m_chkUnderline.isSelected());
    StyleConstants.setStrikeThrough(m_attributes, 
      m_chkStrikethrough.isSelected());
    StyleConstants.setSubscript(m_attributes, 
      m_chkSubscript.isSelected());
    StyleConstants.setSuperscript(m_attributes, 
      m_chkSuperscript.isSelected());
    StyleConstants.setForeground(m_attributes, 
      (Color)m_cbColor.getSelectedItem());
    return m_attributes;
  }

  public int getOption() { return m_option; }

  protected void updatePreview() {
    String name = m_lstFontName.getSelected();
    int size = m_lstFontSize.getSelectedInt();
    if (size <= 0)
      return;
    int style = Font.PLAIN;
    if (m_chkBold.isSelected())
      style |= Font.BOLD;
    if (m_chkItalic.isSelected())
      style |= Font.ITALIC;

    // Bug Alert! This doesn't work if only style is changed.
    Font fn = new Font(name, style, size);
    m_preview.setFont(fn);

    Color c = (Color)m_cbColor.getSelectedItem();
    m_preview.setForeground(c);
    m_preview.repaint();
  }
}

class OpenList extends JPanel implements ListSelectionListener, ActionListener
{
  protected JLabel m_title;
  protected JTextField m_text;
  protected JList m_list;
  protected JScrollPane m_scroll;

  public OpenList(String[] data, String title) {
    setLayout(null);
    m_title = new JLabel(title, JLabel.LEFT);
    add(m_title);
    m_text = new JTextField();
    m_text.addActionListener(this);
    add(m_text);
    m_list = new JList(data);
    m_list.setVisibleRowCount(4);
    m_list.addListSelectionListener(this);
    m_scroll = new JScrollPane(m_list);
    add(m_scroll);
  }

  public void setSelected(String sel) {
    m_list.setSelectedValue(sel, true);
    m_text.setText(sel);
  }

  public String getSelected() { return m_text.getText(); }

  public void setSelectedInt(int value) {
    setSelected(Integer.toString(value));
  }

  public int getSelectedInt() {
    try { 
      return Integer.parseInt(getSelected());
    }
    catch (NumberFormatException ex) { return -1; }
  }

  public void valueChanged(ListSelectionEvent e) {
    Object obj = m_list.getSelectedValue();
    if (obj != null)
      m_text.setText(obj.toString());
  }

  public void actionPerformed(ActionEvent e) {
    ListModel model = m_list.getModel();
    String key = m_text.getText().toLowerCase();
    for (int k=0; k<model.getSize(); k++) {
      String data = (String)model.getElementAt(k);
      if (data.toLowerCase().startsWith(key)) {
        m_list.setSelectedValue(data, true);
        break;
      }
    }
  }

  public void addListSelectionListener(ListSelectionListener lst) {
    m_list.addListSelectionListener(lst);
  }

  public Dimension getPreferredSize() {
    Insets ins = getInsets();
    Dimension d1 = m_title.getPreferredSize();
    Dimension d2 = m_text.getPreferredSize();
    Dimension d3 = m_scroll.getPreferredSize();
    int w = Math.max(Math.max(d1.width, d2.width), d3.width);
    int h = d1.height + d2.height + d3.height;
    return new Dimension(w+ins.left+ins.right, 
      h+ins.top+ins.bottom);
  }

  public Dimension getMaximumSize() {
    Insets ins = getInsets();
    Dimension d1 = m_title.getMaximumSize();
    Dimension d2 = m_text.getMaximumSize();
    Dimension d3 = m_scroll.getMaximumSize();
    int w = Math.max(Math.max(d1.width, d2.width), d3.width);
    int h = d1.height + d2.height + d3.height;
    return new Dimension(w+ins.left+ins.right, 
      h+ins.top+ins.bottom);
  }

  public Dimension getMinimumSize() {
    Insets ins = getInsets();
    Dimension d1 = m_title.getMinimumSize();
    Dimension d2 = m_text.getMinimumSize();
    Dimension d3 = m_scroll.getMinimumSize();
    int w = Math.max(Math.max(d1.width, d2.width), d3.width);
    int h = d1.height + d2.height + d3.height;
    return new Dimension(w+ins.left+ins.right, 
      h+ins.top+ins.bottom);
  }

  public void doLayout() {
    Insets ins = getInsets();
    Dimension d = getSize();
    int x = ins.left;
    int y = ins.top;
    int w = d.width-ins.left-ins.right;
    int h = d.height-ins.top-ins.bottom;

    Dimension d1 = m_title.getPreferredSize();
    m_title.setBounds(x, y, w, d1.height);
    y += d1.height;
    Dimension d2 = m_text.getPreferredSize();
    m_text.setBounds(x, y, w, d2.height);
    y += d2.height;
    m_scroll.setBounds(x, y, w, h-y);
  }
}

class ColorComboRenderer extends JPanel implements ListCellRenderer
{
  protected Color m_color = Color.black;
  protected Color m_focusColor = 
    (Color) UIManager.get("List.selectionBackground");
  protected Color m_nonFocusColor = Color.white;

  public Component getListCellRendererComponent(JList list,
   Object obj, int row, boolean sel, boolean hasFocus)
  {
    if (hasFocus || sel)
      setBorder(new CompoundBorder(
        new MatteBorder(2, 10, 2, 10, m_focusColor),
        new LineBorder(Color.black)));
    else
      setBorder(new CompoundBorder(
        new MatteBorder(2, 10, 2, 10, m_nonFocusColor),
        new LineBorder(Color.black)));

    if (obj instanceof Color) 
      m_color = (Color) obj;
    return this;
  }
    
  public void paintComponent(Graphics g) {
    setBackground(m_color);
    super.paintComponent(g);
  }
}

Three new instance variables are added:

Open an existing RTF file, select a portion of text, and bring up the font dialog. Verify that the initial values correspond to the font attributes of the character element at the current caret position. Try selecting different font attributes and note that the preview component is updated dynamically. Press the "OK" button to apply the selected attributes to the selected text. Also verify that pressing the "Cancel" button does not apply any changes. Figures 20.6 and 20.7 illustrate.

Control over paragraph formatting attributes (e.g. line spacing, text alignment, left and right margins, etc.) is just as necessary in word processor applications as font attribute control. Swing supports a number of paragraph settings discussed below which we discussed briefly in chapter 19. In this section we'll add a dialog specifically for editing these settings. The most interesting aspect of this dialog is a special component we’ve designed to allow a preview of formatted text. In this way the user can get a feeling for how a setting change, or group of changes, will affect the actual document.

<<file figure20-8.gif>>

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;

import javax.swing.*;
import javax.swing.text.*;
import javax.swing.event.*;
import javax.swing.border.*;
import javax.swing.text.rtf.*;
import javax.swing.undo.*;

public class WordProcessor extends JFrame 
{
  // Unchanged code from section 20.6

  protected FontDialog m_fontDialog;
  protected ParagraphDialog m_paragraphDialog;

  protected JMenuBar createMenuBar() {

    // Unchanged code from section 20.6

    m_fontDialog = new FontDialog(this, m_fontNames, m_fontSizes);
    
    m_paragraphDialog = new ParagraphDialog(this);

    // Unchanged code from section 20.6
    
    item = new JMenuItem("Paragraph...");
    item.setMnemonic('p');
    lst = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        WordProcessor.this.repaint();
        AttributeSet a = m_doc.getCharacterElement(
          m_monitor.getCaretPosition()).getAttributes();
        m_paragraphDialog.setAttributes(a);

        Dimension d1 = m_paragraphDialog.getSize();
        Dimension d2 = WordProcessor.this.getSize();
        int x = Math.max((d2.width-d1.width)/2, 0);
        int y = Math.max((d2.height-d1.height)/2, 0);
        m_paragraphDialog.setBounds(x + WordProcessor.this.getX(),
          y + WordProcessor.this.getY(), d1.width, d1.height);

        m_paragraphDialog.show();
        if (m_paragraphDialog.getOption()==JOptionPane.OK_OPTION) {
          setAttributeSet(dlg.getAttributes(), true);
          showAttributes(m_monitor.getCaretPosition());
        }
      }
    };
    item.addActionListener(lst);
    mFormat.add(item);

    mFormat.addSeparator();

    // Unchanged code from section 20.6

    return menuBar;
  }

  // Unchanged code from section 20.6

  protected void setAttributeSet(AttributeSet attr) {
    setAttributeSet(attr, false);
  }

  protected void setAttributeSet(AttributeSet attr, boolean setParagraphAttributes)
  {
    if (m_skipUpdate)
      return;
    int xStart = m_monitor.getSelectionStart();
    int xFinish = m_monitor.getSelectionEnd();
    if (!m_monitor.hasFocus()) {
      xStart = m_xStart;
      xFinish = m_xFinish;
    }
    if (setParagraphAttributes)
      m_doc.setParagraphAttributes(xStart, 
      xFinish - xStart, attr, false);
    else if (xStart != xFinish) 
      m_doc.setCharacterAttributes(xStart, 
        xFinish - xStart, attr, false);
    else {
      MutableAttributeSet inputAttributes = 
        m_kit.getInputAttributes();
      inputAttributes.addAttributes(attr);
    }
  }

  // Unchanged code from section 20.6
}

// Unchanged code from section 20.6

class ParagraphDialog extends JDialog
{
  protected int m_option = JOptionPane.CLOSED_OPTION;
  protected MutableAttributeSet m_attributes;
  protected JTextField m_lineSpacing;
  protected JTextField m_spaceAbove;
  protected JTextField m_spaceBelow;
  protected JTextField m_firstIndent;
  protected JTextField m_leftIndent;
  protected JTextField m_rightIndent;
  protected SmallToggleButton m_btLeft;
  protected SmallToggleButton m_btCenter;
  protected SmallToggleButton m_btRight;
  protected SmallToggleButton m_btJustified;

  protected ParagraphPreview m_preview;

  public ParagraphDialog(JFrame parent) {
    super(parent, "Paragraph", true);
    getContentPane().setLayout(new BoxLayout(getContentPane(), 
      BoxLayout.Y_AXIS));

    JPanel p = new JPanel(new GridLayout(1, 2, 5, 2));

    JPanel ps = new JPanel(new GridLayout(3, 2, 10, 2));
    ps.setBorder(new TitledBorder(new EtchedBorder(), "Space"));
    ps.add(new JLabel("Line spacing:"));
    m_lineSpacing = new JTextField();
    ps.add(m_lineSpacing);
    ps.add(new JLabel("Space above:"));
    m_spaceAbove = new JTextField();
    ps.add(m_spaceAbove);
    ps.add(new JLabel("Space below:"));
    m_spaceBelow = new JTextField();
    ps.add(m_spaceBelow);
    p.add(ps);

    JPanel pi = new JPanel(new GridLayout(3, 2, 10, 2));
    pi.setBorder(new TitledBorder(new EtchedBorder(), "Indent"));
    pi.add(new JLabel("First indent:"));
    m_firstIndent = new JTextField();
    pi.add(m_firstIndent);
    pi.add(new JLabel("Left indent:"));
    m_leftIndent = new JTextField();
    pi.add(m_leftIndent);
    pi.add(new JLabel("Right indent:"));
    m_rightIndent = new JTextField();
    pi.add(m_rightIndent);
    p.add(pi);
    getContentPane().add(p);

    getContentPane().add(Box.createVerticalStrut(5));
    p = new JPanel();
    p.setLayout(new BoxLayout(p, BoxLayout.X_AXIS));
    p.add(Box.createHorizontalStrut(10));
    p.add(new JLabel("Alignment:"));
    p.add(Box.createHorizontalStrut(20));

    ButtonGroup bg = new ButtonGroup();
    ImageIcon img = new ImageIcon("al_left.gif");
    m_btLeft = new SmallToggleButton(false, img, img, "Left");
    bg.add(m_btLeft);
    p.add(m_btLeft);
    img = new ImageIcon("al_center.gif");
    m_btCenter = new SmallToggleButton(false, img, img, "Center");
    bg.add(m_btCenter);
    p.add(m_btCenter);
    img = new ImageIcon("al_right.gif");
    m_btRight = new SmallToggleButton(false, img, img, "Right");
    bg.add(m_btRight);
    p.add(m_btRight);
    img = new ImageIcon("al_justify.gif");
    m_btJustified = new SmallToggleButton(false, img, img, 
      "Justify");
    bg.add(m_btJustified);
    p.add(m_btJustified);
    getContentPane().add(p);

    p = new JPanel(new BorderLayout());
    p.setBorder(new TitledBorder(new EtchedBorder(), "Preview"));
    m_preview = new ParagraphPreview();
    p.add(m_preview, BorderLayout.CENTER);
    getContentPane().add(p);

    p = new JPanel(new FlowLayout());
    JPanel p1 = new JPanel(new GridLayout(1, 2, 10, 2));
    JButton btOK = new JButton("OK");
    ActionListener lst = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        m_option = JOptionPane.OK_OPTION;
        setVisible(false);
      }
    };
    btOK.addActionListener(lst);
    p1.add(btOK);

    JButton btCancel = new JButton("Cancel");
    lst = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        m_option = JOptionPane.CANCEL_OPTION;
        setVisible(false);
      }
    };
    btCancel.addActionListener(lst);
    p1.add(btCancel);
    p.add(p1);
    getContentPane().add(p);

    pack();
    setResizable(false);

    FocusListener flst = new FocusListener() { 
      public void focusGained(FocusEvent e) {}

      public void focusLost(FocusEvent e) { updatePreview(); }
    };
    m_lineSpacing.addFocusListener(flst);
    m_spaceAbove.addFocusListener(flst);
    m_spaceBelow.addFocusListener(flst);
    m_firstIndent.addFocusListener(flst);
    m_leftIndent.addFocusListener(flst);
    m_rightIndent.addFocusListener(flst);

    lst = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        updatePreview();
      }
    };
    m_btLeft.addActionListener(lst);
    m_btCenter.addActionListener(lst);
    m_btRight.addActionListener(lst);
    m_btJustified.addActionListener(lst);
  }

  public void setAttributes(AttributeSet a) {
    m_attributes = new SimpleAttributeSet(a);
    m_lineSpacing.setText(Float.toString(
      StyleConstants.getLineSpacing(a)));
    m_spaceAbove.setText(Float.toString(
      StyleConstants.getSpaceAbove(a)));
    m_spaceBelow.setText(Float.toString(
      StyleConstants.getSpaceBelow(a)));
    m_firstIndent.setText(Float.toString(
      StyleConstants.getFirstLineIndent(a)));
    m_leftIndent.setText(Float.toString(
      StyleConstants.getLeftIndent(a)));
    m_rightIndent.setText(Float.toString(
      StyleConstants.getRightIndent(a)));

    int alignment = StyleConstants.getAlignment(a);
    if (alignment == StyleConstants.ALIGN_LEFT)
      m_btLeft.setSelected(true);
    else if (alignment == StyleConstants.ALIGN_CENTER)
      m_btCenter.setSelected(true);
    else if (alignment == StyleConstants.ALIGN_RIGHT)
      m_btRight.setSelected(true);
    else if (alignment == StyleConstants.ALIGN_JUSTIFIED)
      m_btJustified.setSelected(true);

    updatePreview();
  }

  public AttributeSet getAttributes() {
    if (m_attributes == null)
      return null;
    float value;
    try { 
      value = Float.parseFloat(m_lineSpacing.getText());
      StyleConstants.setLineSpacing(m_attributes, value); 
    } catch (NumberFormatException ex) {}
    try { 
      value = Float.parseFloat(m_spaceAbove.getText());
      StyleConstants.setSpaceAbove(m_attributes, value); 
    } catch (NumberFormatException ex) {}
    try { 
      value = Float.parseFloat(m_spaceBelow.getText());
      StyleConstants.setSpaceBelow(m_attributes, value); 
    } catch (NumberFormatException ex) {}
    try { 
      value = Float.parseFloat(m_firstIndent.getText());
      StyleConstants.setFirstLineIndent(m_attributes, value); 
    } catch (NumberFormatException ex) {}
    try { 
      value = Float.parseFloat(m_leftIndent.getText());
      StyleConstants.setLeftIndent(m_attributes, value); 
    } catch (NumberFormatException ex) {}
    try { 
      value = Float.parseFloat(m_rightIndent.getText());
      StyleConstants.setRightIndent(m_attributes, value); 
    } catch (NumberFormatException ex) {}

    StyleConstants.setAlignment(m_attributes, getAlignment());

    return m_attributes;
  }

  public int getOption() {
    return m_option;
  }

  protected void updatePreview() {
    m_preview.repaint();
  }

  protected int getAlignment() {
    if (m_btLeft.isSelected())
      return StyleConstants.ALIGN_LEFT;
    if (m_btCenter.isSelected())
      return StyleConstants.ALIGN_CENTER;
    else if (m_btRight.isSelected())
      return StyleConstants.ALIGN_RIGHT;
    else
      return StyleConstants.ALIGN_JUSTIFIED;
  }

  class ParagraphPreview extends JPanel
  {
    protected Font m_fn = new Font("Monospace", Font.PLAIN, 6);
    protected String m_dummy = "abcdefghjklm";
    protected float  m_scaleX = 0.25f;
    protected float  m_scaleY = 0.25f;
    protected Random m_random = new Random();

    public ParagraphPreview() {
      setBackground(Color.white);
      setForeground(Color.black);
      setOpaque(true);
      setBorder(new LineBorder(Color.black));
      setPreferredSize(new Dimension(120, 56));
    }

    public void paintComponent(Graphics g) {
      super.paintComponent(g);
      float lineSpacing = 0;
      float spaceAbove  = 0;
      float spaceBelow  = 0;
      float firstIndent = 0;
      float leftIndent  = 0;
      float rightIndent = 0;

      try { 
        lineSpacing = Float.parseFloat(m_lineSpacing.getText());
      } catch (NumberFormatException ex) {}
      try { 
        spaceAbove = Float.parseFloat(m_spaceAbove.getText()); 
      } catch (NumberFormatException ex) {}
      try { 
        spaceBelow = Float.parseFloat(m_spaceBelow.getText()); 
      } catch (NumberFormatException ex) {}
      try { 
        firstIndent = Float.parseFloat(m_firstIndent.getText()); 
      } catch (NumberFormatException ex) {}
      try { 
        leftIndent = Float.parseFloat(m_leftIndent.getText()); 
      } catch (NumberFormatException ex) {}
      try { 
        rightIndent = Float.parseFloat(m_rightIndent.getText()); 
      } catch (NumberFormatException ex) {}

      m_random.setSeed(1959);    // Use same seed every time

      g.setFont(m_fn);
      FontMetrics fm = g.getFontMetrics();
      int h = fm.getAscent();
      int s  = Math.max((int)(lineSpacing*m_scaleY), 1);
      int s1 = Math.max((int)(spaceAbove*m_scaleY), 0) + s;
      int s2 = Math.max((int)(spaceBelow*m_scaleY), 0) + s;
      int y = 5+h;

      int xMarg = 20;
      int x0 = Math.max((int)(firstIndent*m_scaleX)+xMarg, 3);
      int x1 = Math.max((int)(leftIndent*m_scaleX)+xMarg, 3);
      int x2 = Math.max((int)(rightIndent*m_scaleX)+xMarg, 3);
      int xm0 = getWidth()-xMarg;
      int xm1 = getWidth()-x2;
            
      int n = (int)((getHeight()-(2*h+s1+s2-s+10))/(h+s));
      n = Math.max(n, 1);

      g.setColor(Color.lightGray);
      int x = xMarg;
      drawLine(g, x, y, xm0, xm0, fm, StyleConstants.ALIGN_LEFT);
      y += h+s1;

      g.setColor(Color.gray);
      int alignment = getAlignment();
      for (int k=0; k<n; k++) {
        x = (k==0 ? x0 : x1);
        int xLen = (k==n-1 ? xm1/2 : xm1);
        if (k==n-1 && alignment==StyleConstants.ALIGN_JUSTIFIED)
          alignment = StyleConstants.ALIGN_LEFT;
        drawLine(g, x, y, xm1, xLen, fm, alignment);
        y += h+s;
      }

      y += s2-s;
      x = xMarg;
      g.setColor(Color.lightGray);
      drawLine(g, x, y, xm0, xm0, fm, StyleConstants.ALIGN_LEFT);
    }

    protected void drawLine(Graphics g, int x, int y, int xMax, 
     int xLen, FontMetrics fm, int alignment)
    {
      if (y > getHeight()-3)
        return;
      StringBuffer s = new StringBuffer();
      String str1;
      int xx = x;
      while (true) {
        int m = m_random.nextInt(10)+1;
        str1 = m_dummy.substring(0, m)+" ";
        int len = fm.stringWidth(str1);
        if (xx+len >= xLen)
          break;
        xx += len;
        s.append(str1);
      }
      String str = s.toString();

      switch (alignment) {
        case StyleConstants.ALIGN_LEFT:
          g.drawString(str, x, y);
          break;
        case StyleConstants.ALIGN_CENTER:
          xx = (xMax+x-fm.stringWidth(str))/2;
          g.drawString(str, xx, y);
          break;
        case StyleConstants.ALIGN_RIGHT:
          xx = xMax-fm.stringWidth(str);
          g.drawString(str, xx, y);
          break;
        case StyleConstants.ALIGN_JUSTIFIED:
          while (x+fm.stringWidth(str) < xMax)
            str += "a";
          g.drawString(str, x, y);
          break;
      }
    }
  }
}

One new instance variable has been added:

This inner class represents our custom component used to display an imitation paragraph used to preview a set of paragraph attributes. The actual rendering consists of three parts:

1. A light gray text line representing the end of a preceding paragraph. The indent and spacing of this line is not affected by the current paragraph attribute settings.
2. Several gray text lines representing a paragraph being modified. Indentations and line spacing depend on the current paragraph attribute settings. The number of these lines is calculated so as to fill the component’s height naturally, and depends on the current line spacing attribute settings.
3. A light gray text line representing the beginning of a following paragraph. The space between this line and the last paragraph line depends on the current above line spacing attribute. The indentation of this line is not affected by the current paragraph attributes.

Several instance variables are declared in this inner class:

Open an existing RTF file, select some text and bring up the "Paragraph" dialog. Verify that the initial values of all components correspond to the paragraph attributes at the current caret position. Specify new paragraph attributes and note how the preview component is updated dynamically. Press the "OK" button to apply the specified attributes to the selected paragraphs of document text.

Along with font and paragraph dialogs, find and replace functionality has also become a fairly common tool in GUI-based text editing environments. It is safe to assume that most users would be sadly disappointed if this functionality was not included in a new word processor application. In this section we will show how to add this functionality. Traditionally such tools are represented in an "Edit" menu and can be activated by keyboard accelerators. We will use a dialog containing a single tabbed pane with tabs for finding and replacing a specific region of text. We will also provide several options for searching: match case, search whole words only, and search up or down.

<<file figure20-9.gif>>

<<file figure20-10.gif>>

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;

import javax.swing.*;
import javax.swing.text.*;
import javax.swing.event.*;
import javax.swing.border.*;
import javax.swing.text.rtf.*;
import javax.swing.undo.*;

import dl.*;

public class WordProcessor extends JFrame 
{
  // Unchanged code from section 20.7

  protected FontDialog m_fontDialog;
  protected ParagraphDialog m_paragraphDialog;
  protected FindDialog m_findDialog;

  protected JMenuBar createMenuBar() {
    // Unchanged code from section 20.7

    mEdit.addSeparator();

    Action findAction = new AbstractAction("Find...", new ImageIcon("edit_find.gif")) 
    { 
      public void actionPerformed(ActionEvent e) {
        WordProcessor.this.repaint();
        if (m_findDialog==null)
          m_findDialog = new FindDialog(WordProcessor.this, 0);
        else
          m_findDialog.setSelectedIndex(0);

        Dimension d1 = m_findDialog.getSize();
        Dimension d2 = WordProcessor.this.getSize();
        int x = Math.max((d2.width-d1.width)/2, 0);
        int y = Math.max((d2.height-d1.height)/2, 0);
        m_findDialog.setBounds(x + WordProcessor.this.getX(),
          y + WordProcessor.this.getY(), d1.width, d1.height);

        m_findDialog.show();
      }
    };
    item = mEdit.add(findAction);  
    item.setMnemonic('f');
    item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F, 
      KeyEvent.CTRL_MASK));

    Action replaceAction = new AbstractAction("Replace...") { 
      public void actionPerformed(ActionEvent e) {
        WordProcessor.this.repaint();
        if (m_findDialog==null)
          m_findDialog = new FindDialog(WordProcessor.this, 1);
        else
          m_findDialog.setSelectedIndex(1);

        Dimension d1 = m_findDialog.getSize();
        Dimension d2 = WordProcessor.this.getSize();
        int x = Math.max((d2.width-d1.width)/2, 0);
        int y = Math.max((d2.height-d1.height)/2, 0);
        m_findDialog.setBounds(x + WordProcessor.this.getX(),
          y + WordProcessor.this.getY(), d1.width, d1.height);

        m_findDialog.show();
      }
    };
    item =  mEdit.add(replaceAction);  
    item.setMnemonic('r');
    item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_H, 
      KeyEvent.CTRL_MASK));

    menuBar.add(mEdit);

    // Unchanged code from section 20.7
        
    return menuBar;
  }

  // Unchanged code from section 20.7

  public Document getDocument() { return m_doc; }

  public JTextPane getTextPane() { return m_monitor; }

  public void setSelection(int xStart, int xFinish, boolean moveUp) {
    if (moveUp) {
      m_monitor.setCaretPosition(xFinish);
      m_monitor.moveCaretPosition(xStart);
    }
    else
      m_monitor.select(xStart, xFinish);
    m_xStart = m_monitor.getSelectionStart();
    m_xFinish = m_monitor.getSelectionEnd();
  }

  public static void main(String argv[]) {
    new WordProcessor();
  }

  // Unchanged code from section 20.7
}

// Unchanged code from section 20.7

class FindDialog extends JDialog
{
  protected WordProcessor m_owner;
  protected JTabbedPane m_tb;
  protected JTextField m_txtFind1;
  protected JTextField m_txtFind2;
  protected Document m_docFind;
  protected Document m_docReplace;
  protected ButtonModel m_modelWord;
  protected ButtonModel m_modelCase;
  protected ButtonModel m_modelUp;
  protected ButtonModel m_modelDown;

  protected int m_searchIndex = -1;
  protected boolean m_searchUp = false;
  protected String  m_searchData;

  public FindDialog(WordProcessor owner, int index) {
    super(owner, "Find and Replace", false);
    m_owner = owner;

    m_tb = new JTabbedPane();

    // "Find" panel
    JPanel p1 = new JPanel(new BorderLayout());

    JPanel pc1 = new JPanel(new BorderLayout());

    JPanel pf = new JPanel();
    pf.setLayout(new DialogLayout(20, 5));
    pf.setBorder(new EmptyBorder(8, 5, 8, 0));
    pf.add(new JLabel("Find what:"));
        
    m_txtFind1 = new JTextField();
    m_docFind = m_txtFind1.getDocument();
    pf.add(m_txtFind1);
    pc1.add(pf, BorderLayout.CENTER);

    JPanel po = new JPanel(new GridLayout(2, 2, 8, 2));
    po.setBorder(new TitledBorder(new EtchedBorder(), 
      "Options"));

    JCheckBox chkWord = new JCheckBox("Whole words only");
    chkWord.setMnemonic('w');
    m_modelWord = chkWord.getModel();
    po.add(chkWord);

    ButtonGroup bg = new ButtonGroup();
    JRadioButton rdUp = new JRadioButton("Search up");
    rdUp.setMnemonic('u');
    m_modelUp = rdUp.getModel();
    bg.add(rdUp);
    po.add(rdUp);

    JCheckBox chkCase = new JCheckBox("Match case");
    chkCase.setMnemonic('c');
    m_modelCase = chkCase.getModel();
    po.add(chkCase);

    JRadioButton rdDown = new JRadioButton("Search down", true);
    rdDown.setMnemonic('d');
    m_modelDown = rdDown.getModel();
    bg.add(rdDown);
    po.add(rdDown);
    pc1.add(po, BorderLayout.SOUTH);

    p1.add(pc1, BorderLayout.CENTER);

    JPanel p01 = new JPanel(new FlowLayout());
    JPanel p = new JPanel(new GridLayout(2, 1, 2, 8));

    ActionListener findAction = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        findNext(false, true);
      }
    };
    JButton btFind = new JButton("Find Next");
    btFind.addActionListener(findAction);
    btFind.setMnemonic('f');
    p.add(btFind);

    ActionListener closeAction = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        setVisible(false);
      }
    };
    JButton btClose = new JButton("Close");
    btClose.addActionListener(closeAction);
    btClose.setDefaultCapable(true);
    p.add(btClose);
    p01.add(p);
    p1.add(p01, BorderLayout.EAST);

    m_tb.addTab("Find", p1);

    // "Replace" panel
    JPanel p2 = new JPanel(new BorderLayout());

    JPanel pc2 = new JPanel(new BorderLayout());

    JPanel pc = new JPanel();
    pc.setLayout(new DialogLayout(20, 5));
    pc.setBorder(new EmptyBorder(8, 5, 8, 0));
        
    pc.add(new JLabel("Find what:"));
    m_txtFind2 = new JTextField();
    m_txtFind2.setDocument(m_docFind);
    pc.add(m_txtFind2);

    pc.add(new JLabel("Replace:"));
    JTextField txtReplace = new JTextField();
    m_docReplace = txtReplace.getDocument();
    pc.add(txtReplace);
    pc2.add(pc, BorderLayout.CENTER);

    po = new JPanel(new GridLayout(2, 2, 8, 2));
    po.setBorder(new TitledBorder(new EtchedBorder(), 
      "Options"));

    chkWord = new JCheckBox("Whole words only");
    chkWord.setMnemonic('w');
    chkWord.setModel(m_modelWord);
    po.add(chkWord);

    bg = new ButtonGroup();
    rdUp = new JRadioButton("Search up");
    rdUp.setMnemonic('u');
    rdUp.setModel(m_modelUp);
    bg.add(rdUp);
    po.add(rdUp);

    chkCase = new JCheckBox("Match case");
    chkCase.setMnemonic('c');
    chkCase.setModel(m_modelCase);
    po.add(chkCase);

    rdDown = new JRadioButton("Search down", true);
    rdDown.setMnemonic('d');
    rdDown.setModel(m_modelDown);
    bg.add(rdDown);
    po.add(rdDown);
    pc2.add(po, BorderLayout.SOUTH);

    p2.add(pc2, BorderLayout.CENTER);

    JPanel p02 = new JPanel(new FlowLayout());
    p = new JPanel(new GridLayout(3, 1, 2, 8));

    ActionListener replaceAction = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        findNext(true, true);
      }
    };
    JButton btReplace = new JButton("Replace");
    btReplace.addActionListener(replaceAction);
    btReplace.setMnemonic('r');
    p.add(btReplace);

    ActionListener replaceAllAction = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        int counter = 0;
        while (true) {
          int result = findNext(true, false);
          if (result < 0)    // error
            return;
          else if (result == 0)    // no more
            break;
          counter++;
        }
        JOptionPane.showMessageDialog(m_owner, 
          counter+" replacement(s) have been done", "Info",
          JOptionPane.INFORMATION_MESSAGE);
      }
    };
    JButton btReplaceAll = new JButton("Replace All");
    btReplaceAll.addActionListener(replaceAllAction);
    btReplaceAll.setMnemonic('a');
    p.add(btReplaceAll);

    btClose = new JButton("Close");
    btClose.addActionListener(closeAction);
    btClose.setDefaultCapable(true);
    p.add(btClose);
    p02.add(p);
    p2.add(p02, BorderLayout.EAST);
        
    // Make button columns the same size
    p01.setPreferredSize(p02.getPreferredSize());

    m_tb.addTab("Replace", p2);

    m_tb.setSelectedIndex(index);

    getContentPane().add(m_tb, BorderLayout.CENTER);

    WindowListener flst = new WindowAdapter() { 
      public void windowActivated(WindowEvent e) {
        m_searchIndex = -1;
        if (m_tb.getSelectedIndex()==0)
          m_txtFind1.grabFocus();
        else
          m_txtFind2.grabFocus();
      }

      public void windowDeactivated(WindowEvent e) {
        m_searchData = null;
      }
    };
    addWindowListener(flst);

    pack();
    setResizable(false);
  }

  public void setSelectedIndex(int index) {
    m_tb.setSelectedIndex(index);
    setVisible(true);
    m_searchIndex = -1;
  }

  public int findNext(boolean doReplace, boolean showWarnings) {
    JTextPane monitor = m_owner.getTextPane();
    int pos = monitor.getCaretPosition();
    if (m_modelUp.isSelected() != m_searchUp) {
      m_searchUp = m_modelUp.isSelected();
      m_searchIndex = -1;
    }

    if (m_searchIndex == -1) {
      try {
        Document doc = m_owner.getDocument();
        if (m_searchUp)
          m_searchData = doc.getText(0, pos);
        else
          m_searchData = doc.getText(pos, doc.getLength()-pos);
        m_searchIndex = pos;
      }
      catch (BadLocationException ex) {
        warning(ex.toString());
        return -1;
      }
    }
        
    String key = "";
    try { key = m_docFind.getText(0, m_docFind.getLength()); }
    catch (BadLocationException ex) {}
    if (key.length()==0) {
      warning("Please enter the target to search");
      return -1;
    }
    if (!m_modelCase.isSelected()) {
      m_searchData = m_searchData.toLowerCase();
      key = key.toLowerCase();
    }
    if (m_modelWord.isSelected()) {
      for (int k=0; k<Utils.WORD_SEPARATORS.length; k++) {
        if (key.indexOf(Utils.WORD_SEPARATORS[k]) >= 0) {
          warning("The text target contains an illegal "+
            "character \'"+Utils.WORD_SEPARATORS[k]+"\'");
          return -1;
        }
      }
    }

    String replacement = "";
    if (doReplace) {
      try {
        replacement = m_docReplace.getText(0, 
          m_docReplace.getLength());
      } catch (BadLocationException ex) {}
    }

    int xStart = -1;
    int xFinish = -1;
    while (true) 
    {
      if (m_searchUp)
        xStart = m_searchData.lastIndexOf(key, pos-1);
      else
        xStart = m_searchData.indexOf(key, pos-m_searchIndex);
      if (xStart < 0) {
        if (showWarnings)
          warning("Text not found");
        return 0;
      }

      xFinish = xStart+key.length();

      if (m_modelWord.isSelected()) {
        boolean s1 = xStart>0;
        boolean b1 = s1 && !Utils.isSeparator(m_searchData.charAt(
          xStart-1));
        boolean s2 = xFinish<m_searchData.length();
        boolean b2 = s2 && !Utils.isSeparator(m_searchData.charAt(
          xFinish));
                    
        if (b1 || b2)    // Not a whole word
        {
          if (m_searchUp && s1)    // Can continue up
          {
            pos = xStart;
            continue;
          }
          if (!m_searchUp && s2)    // Can continue down
          {
            pos = xFinish;
            continue;
          }
          // Found, but not a whole word, and we cannot continue
          if (showWarnings)
            warning("Text not found");
          return 0;
        }
      }
      break;
    }

    if (!m_searchUp) {
      xStart += m_searchIndex;
      xFinish += m_searchIndex;
    }
    if (doReplace) {
      m_owner.setSelection(xStart, xFinish, m_searchUp);
      monitor.replaceSelection(replacement);
      m_owner.setSelection(xStart, xStart+replacement.length(), 
        m_searchUp);
      m_searchIndex = -1;
    }
    else
      m_owner.setSelection(xStart, xFinish, m_searchUp);
    return 1;
  }

  protected void warning(String message) {
    JOptionPane.showMessageDialog(m_owner, 
      message, "Warning", JOptionPane.INFORMATION_MESSAGE);
  }
}

class Utils
{
  public static final char[] WORD_SEPARATORS = {' ', '\t', '\n',
    '\r', '\f', '.', ',', ':', '-', '(', ')', '[', ']', '{',
    '}', '<', '>', '/', '|', '\\', '\'', '\"'};
    
  public static boolean isSeparator(char ch) {
    for (int k=0; k<WORD_SEPARATORS.length; k++)
      if (ch == WORD_SEPARATORS[k])
        return true;
    return false;
  }
}

Two checkboxes and two radio buttons are placed at the bottom of the panel to control the replacement options. They have identical meaning and representation as the corresponding four controls in the "Find" panel, and to ensure consistency between them, the data models are shared between each ‘identical’ component.

<<file figure20-11.gif>>

   if (m_searchUp)
     xStart = m_searchData.lastIndexOf(key, pos-1);
   else
     xStart = m_searchData.indexOf(key, pos-m_searchIndex);

Open an existing RTF file and use the "Edit" menu, or the appropriate keyboard accelerator, to bring up the "Find and Replace" dialog with the "Find" tab selected. Enter some text to search for, select some search options, and press the "Find Next" button. If your target text is found, the matching region will be highlighted in the base document. Press this button again to find subsequent entries (if any). Verify that the "Whole words only" and "Match case" options function as discussed above. Change focus to the main application window and modify the document and/or change the caret position. Return to the "Find and Replace" dialog and note that the search continues as expected.

Select the "Replace" tab and verify that the state of all search options, including the search target string, are preserved from the "Find" tab (and vice versa when switching back). Enter a replacement string and verify that the "Replace" and "Replace All" buttons work as expected.

soundex String A 4-letter SOUNDEX code

An example of this database, populated with words from several Shakespeare comedies and tragedies, is provided in this example’s directory: Shakespeare.mdb. (This database must be a registered database in your database manager prior to using it. This is not a JDBC tutorial, so we’ll skip the details.)

<<file figure20-12.gif>>

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import java.sql.*;

import javax.swing.*;
import javax.swing.text.*;
import javax.swing.event.*;
import javax.swing.border.*;
import javax.swing.text.rtf.*;
import javax.swing.undo.*;

import dl.*;

public class WordProcessor extends JFrame 
{
  // Unchanged code from section 20.8

  protected JMenuBar createMenuBar() {

    // Unchanged code from section 20.8

    JMenu mTools = new JMenu("Tools");
    mTools.setMnemonic('t');

    Action spellAction = new AbstractAction("Spelling...", new ImageIcon("tools_abc.gif")) 
    { 
      public void actionPerformed(ActionEvent e) {
        SpellChecker checker = new SpellChecker(WordProcessor.this);
        WordProcessor.this.setCursor(Cursor.getPredefinedCursor(
          Cursor.WAIT_CURSOR));
        checker.start();
      }
    };
    item =  mTools.add(spellAction);  
    item.setMnemonic('s');
    item.setAccelerator(KeyStroke.getKeyStroke(
      KeyEvent.VK_F7, 0));
    menuBar.add(mTools);

    m_toolBar.addSeparator();
    m_toolBar.add(new SmallButton(spellAction, 
      "Spell checker"));

    getContentPane().add(m_toolBar, BorderLayout.NORTH);
        
    return menuBar;
  }

  // Unchanged code from section 20.8
}

class OpenList extends JPanel
 implements ListSelectionListener, ActionListener
{
  // Unchanged code from section 20.6

  public OpenList(String title, int numCols) {
    setLayout(null);
    m_title = new JLabel(title, JLabel.LEFT);
    add(m_title);
    m_text = new JTextField(numCols);
    m_text.addActionListener(this);
    add(m_text);
    m_list = new JList();
    m_list.setVisibleRowCount(4);
    m_list.addListSelectionListener(this);
    m_scroll = new JScrollPane(m_list);
    add(m_scroll);
  }

  public void appendResultSet(ResultSet results, int index, 
   boolean toTitleCase)
  {
    m_text.setText("");
    DefaultListModel model = new DefaultListModel();
    try {
      while (results.next()) {
        String str = results.getString(index);
        if (toTitleCase)
          str = Utils.titleCase(str); 
        model.addElement(str);
      }
    }
    catch (SQLException ex) {
      System.err.println("appendResultSet: "+ex.toString());
    }
    m_list.setModel(model);
    if (model.getSize() > 0)
      m_list.setSelectedIndex(0);
  }

  // Unchanged code from section 20.6
}

// Unchanged code from section 20.6

class SpellChecker extends Thread
{
  protected static String SELECT_QUERY = 
    "SELECT Data.word FROM Data WHERE Data.word = ";
  protected static String SOUNDEX_QUERY = 
    "SELECT Data.word FROM Data WHERE Data.soundex = ";

  protected WordProcessor m_owner;
  protected Connection m_conn;
  protected DocumentTokenizer m_tokenizer;
  protected Hashtable  m_ignoreAll;
  protected SpellingDialog m_dlg;

  public SpellChecker(WordProcessor owner) {
    m_owner = owner;
  }

  public void run() {
    JTextPane monitor = m_owner.getTextPane();
    m_owner.setEnabled(false);
    monitor.setEnabled(false);

    m_dlg = new SpellingDialog(m_owner);
    m_ignoreAll = new Hashtable();

    try {
      // Load the JDBC-ODBC bridge driver
      Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
      m_conn = DriverManager.getConnection(
        "jdbc:odbc:Shakespeare", "admin", "");
      Statement selStmt = m_conn.createStatement();

      Document doc = m_owner.getDocument();
      int pos = monitor.getCaretPosition();
      m_tokenizer = new DocumentTokenizer(doc, pos);
      String word, wordLowCase;

      while (m_tokenizer.hasMoreTokens()) {
        word = m_tokenizer.nextToken();
        if (word.equals(word.toUpperCase()))
          continue;
        if (word.length()<=1)
          continue;
        if (Utils.hasDigits(word))
          continue;
        wordLowCase = word.toLowerCase();
        if (m_ignoreAll.get(wordLowCase) != null)
          continue;
                
        ResultSet results = selStmt.executeQuery(
          SELECT_QUERY+"'"+wordLowCase+"'");
        if (results.next())
          continue;

        results = selStmt.executeQuery(SOUNDEX_QUERY+
          "'"+Utils.soundex(wordLowCase)+"'");
        m_owner.setSelection(m_tokenizer.getStartPos(), 
          m_tokenizer.getEndPos(), false);
        if (!m_dlg.suggest(word, results))
          break;
      }

      m_conn.close();
      System.gc();
      monitor.setCaretPosition(pos);
    }
    catch (Exception ex) {
      ex.printStackTrace();
      System.err.println("SpellChecker error: "+ex.toString());
    }
        
    monitor.setEnabled(true);
    m_owner.setEnabled(true);
    m_owner.setCursor(Cursor.getPredefinedCursor(
      Cursor.DEFAULT_CURSOR));
  }

  protected void replaceSelection(String replacement) {
    int xStart = m_tokenizer.getStartPos();
    int xFinish = m_tokenizer.getEndPos();
    m_owner.setSelection(xStart, xFinish, false);
    m_owner.getTextPane().replaceSelection(replacement);
    xFinish = xStart+replacement.length();
    m_owner.setSelection(xStart, xFinish, false);
    m_tokenizer.setPosition(xFinish);
  }

  protected void addToDB(String word) {
    String sdx = Utils.soundex(word);
    try {
      Statement stmt = m_conn.createStatement();
      stmt.executeUpdate(
        "INSERT INTO DATA (Word, Soundex) VALUES ('"+
        word+"', '"+sdx+"')");
    }
    catch (Exception ex) {
      ex.printStackTrace();
      System.err.println("SpellChecker error: "+ex.toString());
    }
  }

  class SpellingDialog extends JDialog
  {
    protected JTextField  m_txtNotFound;
    protected OpenList    m_suggestions;

    protected String   m_word;
    protected boolean  m_continue;

    public SpellingDialog(WordProcessor owner) {
      super(owner, "Spelling", true);

      JPanel p = new JPanel();
      p.setBorder(new EmptyBorder(5, 5, 5, 5));
      p.setLayout(new BoxLayout(p, BoxLayout.X_AXIS));
      p.add(new JLabel("Not in dictionary:"));
      p.add(Box.createHorizontalStrut(10));
      m_txtNotFound = new JTextField();
      m_txtNotFound.setEditable(false);
      p.add(m_txtNotFound);
      getContentPane().add(p, BorderLayout.NORTH);
            
      m_suggestions = new OpenList("Change to:", 12);
      m_suggestions.setBorder(new EmptyBorder(0, 5, 5, 5));
      getContentPane().add(m_suggestions, BorderLayout.CENTER);

      JPanel p1 = new JPanel();
      p1.setBorder(new EmptyBorder(20, 0, 5, 5));
      p1.setLayout(new FlowLayout());
      p = new JPanel(new GridLayout(3, 2, 8, 2));
            
      JButton bt = new JButton("Change");
      ActionListener lst = new ActionListener() { 
        public void actionPerformed(ActionEvent e) {
          replaceSelection(m_suggestions.getSelected());
          m_continue = true;
          setVisible(false);
        }
      };
      bt.addActionListener(lst);
      bt.setMnemonic('c');
      p.add(bt);

      bt = new JButton("Add");
      lst = new ActionListener() { 
        public void actionPerformed(ActionEvent e) {
          addToDB(m_word.toLowerCase());
          m_continue = true;
          setVisible(false);
        }
      };
      bt.addActionListener(lst);
      bt.setMnemonic('a');
      p.add(bt);

      bt = new JButton("Ignore");
      lst = new ActionListener() { 
        public void actionPerformed(ActionEvent e) {
          m_continue = true;
          setVisible(false);
        }
      };
      bt.addActionListener(lst);
      bt.setMnemonic('i');
      p.add(bt);

      bt = new JButton("Suggest");
      lst = new ActionListener() { 
        public void actionPerformed(ActionEvent e) {
          try {
            m_word = m_suggestions.getSelected();
            Statement selStmt = m_conn.createStatement();
            ResultSet results = selStmt.executeQuery(
              SELECT_QUERY+"'"+m_word.toLowerCase()+"'");
            boolean toTitleCase = Character.isUpperCase(
              m_word.charAt(0));
            m_suggestions.appendResultSet(results, 1, 
              toTitleCase);
          }
          catch (Exception ex) {
            ex.printStackTrace();
            System.err.println("SpellChecker error: "+
              ex.toString());
          }
        }
      };
      bt.addActionListener(lst);
      bt.setMnemonic('s');
      p.add(bt);

      bt = new JButton("Ignore All");
      lst = new ActionListener() { 
        public void actionPerformed(ActionEvent e) {
          m_ignoreAll.put(m_word.toLowerCase(), m_word);
          m_continue = true;
          setVisible(false);
        }
      };
      bt.addActionListener(lst);
      bt.setMnemonic('g');
      p.add(bt);

      bt = new JButton("Close");
      lst = new ActionListener() { 
        public void actionPerformed(ActionEvent e) {
          m_continue = false;
          setVisible(false);
        }
      };
      bt.addActionListener(lst);
      bt.setDefaultCapable(true);
      p.add(bt);
      p1.add(p);
      getContentPane().add(p1, BorderLayout.EAST);

      pack();
      setResizable(false);
      Dimension d1 = getSize();
      Dimension d2 = owner.getSize();
      int x = Math.max((d2.width-d1.width)/2, 0);
      int y = Math.max((d2.height-d1.height)/2, 0);
      setBounds(x + owner.getX(), 
        y + owner.getY(), d1.width, d1.height);
    }

    public boolean suggest(String word, ResultSet results) {
      m_continue = false;
      m_word = word;
      m_txtNotFound.setText(word);
      boolean toTitleCase = Character.isUpperCase(
        word.charAt(0));
      m_suggestions.appendResultSet(results, 1, toTitleCase);
      show();
      return m_continue;
    }
  }
}

class DocumentTokenizer
{
  protected Document m_doc;
  protected Segment  m_seg;
  protected int m_startPos;
  protected int m_endPos;
  protected int m_currentPos;

  public DocumentTokenizer(Document doc, int offset) {
    m_doc = doc;
    m_seg = new Segment();
    setPosition(offset);
  }

  public boolean hasMoreTokens() {
    return (m_currentPos < m_doc.getLength());
  }

  public String nextToken() {
    StringBuffer s = new StringBuffer();
    try {
      // Trim leading seperators
      while (hasMoreTokens()) {
        m_doc.getText(m_currentPos, 1, m_seg);
        char ch = m_seg.array[m_seg.offset];
        if (!Utils.isSeparator(ch)) {
          m_startPos = m_currentPos;
          break;
        }
        m_currentPos++;
      }
            
      // Append characters
      while (hasMoreTokens()) {
        m_doc.getText(m_currentPos, 1, m_seg);
        char ch = m_seg.array[m_seg.offset];
        if (Utils.isSeparator(ch)) {
          m_endPos = m_currentPos;
          break;
        }
        s.append(ch);
        m_currentPos++;
      }
    }
    catch (BadLocationException ex) {
      System.err.println("nextToken: "+ex.toString());
      m_currentPos = m_doc.getLength();
    }
    return s.toString();
  }

  public int getStartPos() { return m_startPos; }

  public int getEndPos() { return m_endPos; }
    
  public void setPosition(int pos) { 
    m_startPos = pos;
    m_endPos = pos;
    m_currentPos = pos;
  }
}

class Utils
{
  // Unchanged code from section 20.8

  public static String soundex(String word) {
    char[] result = new char[4];
    result[0] = word.charAt(0);
    result[1] = result[2] = result[3] = '0';
    int index = 1;
        
    char codeLast = '*';
    for (int k=1; k<word.length(); k++) {
      char ch = word.charAt(k);
      char code = ' ';
      switch (ch) {
        case 'b': case 'f': case 'p': case 'v': 
          code = '1';
          break;
        case 'c': case 'g': case 'j': case 'k': 
        case 'q': case 's': case 'x': case 'z': 
          code = '2';
          break;
        case 'd': case 't': 
          code = '3';
          break;
        case 'l': 
          code = '4';
          break;
        case 'm': case 'n': 
          code = '5';
          break;
        case 'r': 
          code = '6';
          break;
        default:
          code = '*';
          break;
      }
      if (code == codeLast)
        code = '*';
      codeLast = code;
      if (code != '*') {
        result[index] = code;
        index++;
        if (index > 3)
          break;
      }
    }
    return new String(result);
  }

  public static boolean hasDigits(String word) {
    for (int k=1; k<word.length(); k++) {
      char ch = word.charAt(k);
      if (Character.isDigit(ch))
        return true;
    }
    return false;
  }

  public static String titleCase(String source) {
    return Character.toUpperCase(source.charAt(0)) + 
      source.substring(1);
  }
}

This custom component receives new functionality for use in our new spell checker dialog. First, we add a new constructor which assigns a given number of columns to the text field, and does not initialize the list component.

Five instance variables are declared:

This inner class represents a dialog which prompts the user to verify or correct a certain word if it is not found in the database. The user can select one of several actions in response: ignore the given word, ignore all occurrences of that word in the document, replace that word with another word, add this word to the database and consider it correct in any future matches, or cancel the spell check. Four instance variables are declared:

The button titled "Add" adds the word in question to the spelling database. This word will then be considered correct in future queries. In this way we allow the spell checker to "learn" new words (i.e. add them to the dictionary).

The button titled "Ignore" simply skips the current word and continues spell checking the remaining text.

The button titled "Ignore All" does the same as the "Ignore" button, but also stores the word in question in the collection of words to ignore, so the next time the spell checker finds this word it will be deemed correct. The difference between "Ignore All" and "Add" is that ignored words will only be ignored during a single spell check, whereas words added to the database will persist as long as the database data does.

2 C,S,G,J,K,Q,X,Z

3 D,T

4 L

5 M,N

6 R

* (all others)

Open an existing RTF file and try running a complete spell check. Try adding some words to the dictionary and use the "Ignore All" button to avoid questioning a word again during that spell check. Try using the "Suggest" button to query the database for more suggestions based on our SOUNDEX algorithm. Click the "Change" button to accept a suggestion or a change typed into the text field. Click the "Ignore" button to ignore the current word being questioned.