font family of empty DefaultStyledDocument

[Ilja Preuss]

I am currently implementing a small text editor component with a combo box for the font family used, using a JTextPane with a DefaultStyledDocument.

Problem is, when I initialize it with an empty DefaultStyledDocument, the font family is "Dialog". I want it to be a different one, for example "Times New Roman".

The only way I've found to change the "default font" is to override the document's createDefaultRoot() method, but this feels really clumsy. I assume that there must be a better way to do it, but no matter how long I look at the javadoc or google the net, I can't find it.

Any hint in the right direction would be highly appreciated. We are using JDK 1.4.2.

[Alan Moore]

First off, the font is a property of the JTextComponent, not of the Document. The default font is set by the LookAndFeel, which stores it in the UIDefaults table. To change the default font for all JTextPanes, place your own font in the table under the appropriate key:

UIManager.put("TextPane.font", new Font("Times New Roman", Font.PLAIN, 12));

Do this before you create any components.

[Ilja Preuss]

Originally posted by Alan Moore:
First off, the font is a property of the JTextComponent, not of the Document.

Ah, no. A JTextPane can show text for which the font changes inside the text itself. In this case, it's a property of the content inside the document.

[H Lander]

You can do it using actions defined by javax.swing.text.StyledEditorKit.
The code below demonstrates this.

Good luck,
Henry

import java.awt.*;
import java.awt.event.ActionEvent;
import javax.swing.*;
import javax.swing.text.*;
 
public class TextWindow extends JFrame 
{
  public static void main ( String[] args ) 
  {
    new TextWindow();
  }
 
  public TextWindow() 
  {
    super();
    
    JTextPane theTP = new JTextPane();
    
    getContentPane().add(theTP);
    setPreferredSize(new Dimension(333, 444));
    
    // -------------------------------
    
    final String FONT_FAMILY = "Monospaced";
    final int    FONT_SIZE = 22;
    final AbstractAction FONT_NAME_ACTION = new StyledEditorKit.FontFamilyAction("set-font-family", null);
    final AbstractAction FONT_SIZE_ACTION = new StyledEditorKit.FontSizeAction("set-font-size", 0);    
    ActionEvent theEvent = null;      
 
    theEvent = new ActionEvent(theTP, ActionEvent.ACTION_PERFORMED, FONT_FAMILY);        
    FONT_NAME_ACTION.actionPerformed(theEvent);    
    theEvent = new ActionEvent(theTP, ActionEvent.ACTION_PERFORMED, Integer.toString(FONT_SIZE));        
    FONT_SIZE_ACTION.actionPerformed(theEvent);   
    
    theTP.setText("Here is some " + FONT_FAMILY + " " + FONT_SIZE + " text.");
    // -------------------------------
    
    pack();
    setVisible(true);
  } 
} 

[Alan Moore]

But in an empty document, the only font setting that makes any sense is the UIDefaults setting. There's no point querying the document to find out which Style is in effect if you haven't set any yet.

[Ilja Preuss]

Originally posted by H Lander:
You can do it using actions defined by javax.swing.text.StyledEditorKit.
The code below demonstrates this.

Thanks Henry. That still looks clumsy to me, but I will take a look at the source code of the action to see wether it gives me new ideas...

[Ilja Preuss]

Originally posted by Alan Moore:
But in an empty document, the only font setting that makes any sense is the UIDefaults setting. There's no point querying the document to find out which Style is in effect if you haven't set any yet.

We must still be misunderstanding. I *want* to set the style of the empty document, so that when I type something in the the JTextPane, it's in the style I've set, not in the default style. And I'm able to do that, by overriding createDefaultRoot as I said above (I can post the code tomorrow, when I'm at work again) - it just doesn't feel like the correct way to do it.

I have a JCombobox linked to the JTextPane via a CaretListener, which shows the font family set at the caret position. Even for a non-empty document with text in, say, Times New Roman and Helvetica, the combobox shows the font family Dialog for the beginning and the end of the text unless I overwrite createDefaultRoot. I don't want to allow Dialog as a font family.

[Ilja Preuss]

Originally posted by Ilja Preuss:

Thanks Henry. That still looks clumsy to me, but I will take a look at the source code of the action to see wether it gives me new ideas...

Mhh, the action basically calls setCharacterAttributes on the document. I thought we already tried that, but we might have done something wrong. Will try again when I'm back at work again tomorrow.

[H Lander]

I agree its a bit clumsy. Although if you define methods to set the Font Size, Family and other attributes, and call these methods from the GUI controls of your text editor it will work quite fine.

Good idea looking at what the Action does.

Regards,
Henry

[Ilja Preuss]

Originally posted by H Lander:
Although if you define methods to set the Font Size, Family and other attributes, and call these methods from the GUI controls of your text editor it will work quite fine.

Yes - in fact I have that already working. It's really only the initial state that I'm struggling with. I currently assume that I was just blind today. Let's see what tomorrow brings (here in germany, tomorrow is only two hours away now... ).

[Michael Dunn]

setting the font of the JTextPane doesn't give you the initial font you want?

[Craig Wood]

import java.awt.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.text.*;
 
public class StyledDocTest implements CaretListener
{
    public void caretUpdate(CaretEvent e)
    {
        int position = e.getDot();
        JTextPane textPane = (JTextPane)e.getSource();
        DefaultStyledDocument doc =
            (DefaultStyledDocument)textPane.getStyledDocument(); 
        Style caretStyle = doc.getLogicalStyle(position);
        System.out.println("caretStyle family = " + 
                            caretStyle.getAttribute(StyleConstants.FontFamily));
    }
 
    private JTextPane getTextPane()
    {
        JTextPane textPane = new JTextPane();
        System.out.println(textPane.getDocument().getClass().getName());
        Style newDef = StyleContext.getDefaultStyleContext().
                             getStyle(StyleContext.DEFAULT_STYLE);
        StyleConstants.setFontFamily(newDef, "lucida bright regular");
        StyleConstants.setFontSize(newDef, 18);
        StyleConstants.setItalic(newDef, false);
        StyleConstants.setBold(newDef, false);
        StyleConstants.setForeground(newDef,
                           UIManager.getColor("TextPane.foreground"));
        System.out.println("newDef = " + newDef);
        java.util.Enumeration e = newDef.getAttributeNames();
        while(e.hasMoreElements())
        {
            Object o = e.nextElement();
            Object attr = newDef.getAttribute(o);
            System.out.println(o + " : " + attr);
        }
        textPane.setLogicalStyle(newDef);
        textPane.addCaretListener(this);
        return textPane;
    }
 
    public static void main(String[] args)
    {
        StyledDocTest test = new StyledDocTest();
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.getContentPane().add(test.getTextPane());
        f.setSize(400,400);
        f.setLocation(200,200);
        f.setVisible(true);
    }
}

[Ilja Preuss]

Originally posted by Michael Dunn:
setting the font of the JTextPane doesn't give you the initial font you want?

Didn't try it, but it doesn't sound right to me, as the font should be defined by the document, not by the component that shows the document. Might try it if nothing else works, though...

[Ilja Preuss]

Craig, setLogicalStyle looks promising. I will have to read about it, and of course try it.

[Ilja Preuss]

Originally posted by Ilja Preuss:
Craig, setLogicalStyle looks promising. I will have to read about it, and of course try it.

Now I remember: the problem with setLogicalStyle is that it applies to a whole paragraph.

import javax.swing.JFrame;
import javax.swing.JTextPane;
import javax.swing.event.CaretEvent;
import javax.swing.event.CaretListener;
import javax.swing.text.BadLocationException;
import javax.swing.text.DefaultStyledDocument;
import javax.swing.text.SimpleAttributeSet;
import javax.swing.text.Style;
import javax.swing.text.StyleConstants;
import javax.swing.text.StyleContext;
 
public class StyledDocTest implements CaretListener {
  public void caretUpdate(CaretEvent e) {
    int position = e.getDot();
    JTextPane textPane = (JTextPane) e.getSource();
    DefaultStyledDocument doc = (DefaultStyledDocument) textPane.getStyledDocument();
    Style caretStyle = doc.getLogicalStyle(position);
    System.out.println("caretStyle family = " + caretStyle.getAttribute(StyleConstants.FontFamily));
  }
 
  private JTextPane getTextPane() throws BadLocationException {
    final DefaultStyledDocument document = new DefaultStyledDocument();
    document.insertString(0, "default ", new SimpleAttributeSet());
    SimpleAttributeSet timesAttributeSet = new SimpleAttributeSet();
    StyleConstants.setFontFamily(timesAttributeSet, "Times New Roman");
    document.insertString(document.getLength(), "Time New Roman", timesAttributeSet);
    JTextPane textPane = new JTextPane(document);
    System.out.println(textPane.getDocument().getClass().getName());
    Style newDef = StyleContext.getDefaultStyleContext().getStyle(StyleContext.DEFAULT_STYLE);
    StyleConstants.setFontFamily(newDef, "lucida bright regular");
    textPane.setLogicalStyle(newDef);
    textPane.addCaretListener(this);
    return textPane;
  }
 
  public static void main(String[] args) throws BadLocationException {
    StyledDocTest test = new StyledDocTest();
    JFrame f = new JFrame();
    f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    f.getContentPane().add(test.getTextPane());
    f.setSize(400, 400);
    f.setLocation(200, 200);
    f.setVisible(true);
  }
}

This shows lucida for all the text, even for the one that is in Times New Roman. I need to show it the actual font of the current character. (In fact I will later need to convert the document to some native format, preserving all the font settings done in the editor.)

[Ilja Preuss]

When I add the following line to caretUpdate, it seems to work!

    System.out.println("character family = "
        + doc.getCharacterElement(position).getAttributes().getAttribute(
            CharacterConstants.FontFamily));

Now I need to try this in the production code...

[Ilja Preuss]

It looks like it can even be done in the document itself:

    Style newDef = document.getStyle(StyleContext.DEFAULT_STYLE);
    StyleConstants.setFontFamily(newDef, "lucida bright regular");

[Ilja Preuss]

I was struggling with some other problems integrating this code into our application, but now I've hit another road block: setting the document on a JTextPane seems to reset the default style or something:

    DefaultStyledDocument document = new DefaultStyledDocument();
    Style newDef = document.getStyle(StyleContext.DEFAULT_STYLE);
    StyleConstants.setFontFamily(newDef, "Times New Roman");
    System.out.println("before: "
        + document.getCharacterElement(0).getAttributes().getAttribute(
            CharacterConstants.FontFamily));
    new JTextPane(document);
    System.out.println("after: "
        + document.getCharacterElement(0).getAttributes().getAttribute(
            CharacterConstants.FontFamily));

The output of this is

before: Times New Roman
after: Dialog

Problem is, I want to create the document outside the class that is creating the JTextPane.

[Ilja Preuss]

The BasicTextPaneUI changes the style to the default font... :roll:

[Ilja Preuss]

Originally posted by Ilja Preuss:
The BasicTextPaneUI changes the style to the default font... :roll:

No, to the font of the component. So it looks like Michael was right. Sorry for ignoring you, Micheal...

This still looks backward to me, though...

[Ilja Preuss]

So the BasicTextPaneUI changes the default style, which is used as the documents style by default. So if a set a different style, that seems to work:

    StyleContext styleContext = new StyleContext();
    DefaultStyledDocument document = new DefaultStyledDocument(styleContext);
    Style newDef = styleContext.new NamedStyle();
    StyleConstants.setFontFamily(newDef, "Times New Roman");
    document.setLogicalStyle(0, newDef);
    System.out.println("before: "
        + document.getCharacterElement(0).getAttributes().getAttribute(
            CharacterConstants.FontFamily));
    new JTextPane(document);
    System.out.println("after: "
        + document.getCharacterElement(0).getAttributes().getAttribute(
            CharacterConstants.FontFamily));

I'm not sure wether I'm using styles correctly here. For example, is using a NamedStyle the correct way of doing it?

Any hints for simplifying the code would be highly appreciated.

And thanks to anyone who contributed so far - without you, I would have shot myself...
[ October 27, 2005: Message edited by: Ilja Preuss ]

[Craig Wood]

import java.awt.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.text.*;
 
public class StyledDocTest implements CaretListener {
    public void caretUpdate(CaretEvent e) {
        int position = e.getDot();
        JTextPane textPane = (JTextPane)e.getSource();
        DefaultStyledDocument doc =
            (DefaultStyledDocument)textPane.getStyledDocument(); 
        System.out.println("caret position family = " + 
                            doc.getCharacterElement(position).getAttributes().
                                getAttribute(StyleConstants.FontFamily));
    }
 
    private void resetDocStyle(StyledDocument doc) {
        Style defStyle = doc.getStyle(StyleContext.DEFAULT_STYLE);
        System.out.println("\t*** resetting doc style ***\nbefore removal = " +
                            defStyle.getAttribute(StyleConstants.FontFamily));
        defStyle.removeAttribute(StyleConstants.FontFamily);
        System.out.println("after removal  = " +
                            defStyle.getAttribute(StyleConstants.FontFamily));
        StyleConstants.setFontFamily(defStyle, "times new roman");
        System.out.println("defStyle = " + defStyle);
        //showAttributes("reset doc style", defStyle);
    }
 
    private JTextPane getTextPane() {
        JTextPane textPane = new JTextPane();
        textPane.setFont(new Font("lucida bright regular", Font.PLAIN, 18));
        textPane.addCaretListener(this);
        return textPane;
    }
 
    private StyledDocument getStyledDocument() {
        return new DefaultStyledDocument();
    }
 
    private void showAttributes(String s, Style style) {
        System.out.println("style attributes for " + s);
        java.util.Enumeration e = style.getAttributeNames();
        while(e.hasMoreElements()) {
            Object o = e.nextElement();
            Object attr = style.getAttribute(o);
            System.out.println(o + " : " + attr);
        }
    }
 
    public static void main(String[] args) {
        StyledDocTest test = new StyledDocTest();
        JTextPane textPane = test.getTextPane();
        textPane.setStyledDocument(test.getStyledDocument());
        Style def = textPane.getStyle(StyleContext.DEFAULT_STYLE);
        test.showAttributes("textpane after doc set", def);
        StyledDocument doc = textPane.getStyledDocument();
        test.resetDocStyle(doc);
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.getContentPane().add(textPane);
        f.setSize(400,400);
        f.setLocation(200,200);
        f.setVisible(true);
    }
}

[Ilja Preuss]

Craig, your code would work, but it doesn't allow me to separate concerns in the way I would like. In my design currently the code that creates and configures the document doesn't know about the JTextPane at all, and therefore also doesn't know when it gets added to one.

I guess I could wrap the document into a kind of factory which has a reset method that gets called after the document got added to the JTextPane, but that sounds even more complicated than the code I have now...

[Brian Cole]

Originally posted by Ilja Preuss:
I was struggling with some other problems integrating this code into our application, but now I've hit another road block: setting the document on a JTextPane seems to reset the default style or something:

    DefaultStyledDocument document = new DefaultStyledDocument();
    Style newDef = document.getStyle(StyleContext.DEFAULT_STYLE);
    StyleConstants.setFontFamily(newDef, "Times New Roman");
    System.out.println("before: "
        + document.getCharacterElement(0).getAttributes().getAttribute(
            CharacterConstants.FontFamily));
    new JTextPane(document);
    System.out.println("after: "
        + document.getCharacterElement(0).getAttributes().getAttribute(
            CharacterConstants.FontFamily));

The output of this is

before: Times New Roman
after: Dialog

Problem is, I want to create the document outside the class that is creating the JTextPane.

It's not pretty, but it will work if you replace
new JTextPane(document) with

  
    JTextPane tp = new JTextPane();
    tp.setFont(StyleContext.getDefaultStyleContext().getFont(
                 document.getStyle(StyleContext.DEFAULT_STYLE)));
    tp.setDocument(document);

Note that StyleContext.getDefaultStyleContext() might not
be appropriate if you're doing something special with your
Documents' StyleContexts.

[Ilja Preuss]

Originally posted by Brian Cole:
It's not pretty, but it will work if you replace
new JTextPane(document) with

  
    JTextPane tp = new JTextPane();
    tp.setFont(StyleContext.getDefaultStyleContext().getFont(
                 document.getStyle(StyleContext.DEFAULT_STYLE)));
    tp.setDocument(document);

Thanks Brian!

I already thought about something like this, but assumed that it would be more complicated...

And you are right - it isn't pretty. I'm not yet sure wether I like it better than the alternatives. Mhh...

[Steve Thames]

I first encountered this problem about a year ago and found that it was causing many other people trouble. I recently returned to the problem and found a resolution that I thought I would share in the hopes it will help someone else.

The problem, fundamentally, is that Sun, sometime in the past, implemented a generic UI interface that can be easily changed to fit the target environment--Window, Mac, etc. These Motifs can be globally selected and affect all styles used the in the application/applet. The way they did this, in the case of the JTextPane/JEditorPane, was to modify the default style in the StyleContext object (getAttributeContext()) of the document itself. The pane gets its default settings from the default style context.

This may have made sense to someone, for some reason. Personally, I would have set the defaults in the default StyleContext and not have the UI mess with it at all. But that's just me.

The effect of this was to completly short-circuit the mechanism for using styles the way we want to because the JTextPane/JEditorPane will get its font/color attributes from the StyleContext. Since the UI Motif will resent them no matter what you do, the feature is lost.

My solution turned out to be seems like a hack but actually turns out to be rather elegant because it is encapsulated to one object--StyleContext. I created a subclass of StyleContext and use this to create the default document. This subclass watches the default style and resets it to my values whenever it is changed by something else--such as the UI.

Here is the code. I hope someone finds it useful.

/*******************************************************************************
* $Id: WSStyleContext.java,v 1.1.2.1 2007/10/26 01:33:05 steve Exp $
* ------------------------------------------------------------------------------
* $Log: WSStyleContext.java,v $
* Revision 1.1.2.1  2007/10/26 01:33:05  steve
* Fixed default style context issue.  Still testing new Reader/Writer.
*
*******************************************************************************/
package wsapp.rtf;
 
import java.awt.Color;
import java.awt.Font;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.text.AttributeSet;
import javax.swing.text.SimpleAttributeSet;
import javax.swing.text.Style;
import javax.swing.text.StyleConstants;
import javax.swing.text.StyleContext;
import javax.swing.plaf.FontUIResource;
 
/*******************************************************************************
* StyleContext for use with Webscriber documents.  This object is used to create
* a new WSDocument object.  It establishes the default style for the document
* and protects the style from change by the Java UI.
* <p>
* In order to create one global setting for UI fonts and other resources,
* apparently, the UI modifies the StyleContext of the document to be what the
* global setting is.  This was really stupid in that it made it nearly
* impossible to use the default style for anything other than the UI font or
* foreground color.
* <p>
* This object adds a listener to the default style and restores it to its
* default value whenever an attribute changes.  Performance should not suffer
* since these changes will only be made when the UI modifies the default style.
*
* @version $Revision: 1.1.2.1 $
*******************************************************************************/
public class WSStyleContext extends StyleContext
  {
  /*****************************************************************************
  * Constants
  *****************************************************************************/
  /**
  * Attribute key to reference the default font according to Sun source code.
  * Used in javax.swing.text.StyleContext.getFont() to resolve the default font.
  * <p>
  * This turns out not to be the case.  This constant is no longer used by
  * getFont() if it ever was.  We maintain it anyway.
  */
  protected static final String FONT_ATTRIBUTE_KEY = "FONT_ATTRIBUTE_KEY";
 
  /*****************************************************************************
  * Properties
  *****************************************************************************/
  /** Default Style Attributes */ protected SimpleAttributeSet m_Default;
  /** Restoring Defaults Flag */  protected boolean            m_Restoring;
 
  /*****************************************************************************
  * Constructor */
  /**
  * Instantiates the StyleContext.  Build the Default Style Attributes and adds
  * the ChangeListener to the default style.
  *****************************************************************************/
  public WSStyleContext()
    {
    super();
 
    Style s = getStyle(StyleContext.DEFAULT_STYLE);
 
    /*--------------------------------------*/
    /* Create the default style attributes. */
    /*--------------------------------------*/
    m_Default = new SimpleAttributeSet(s);
 
    StyleConstants.setFontFamily(m_Default, "Times New Roman");
    StyleConstants.setFontSize  (m_Default, 12);
    StyleConstants.setBold      (m_Default, false);
    StyleConstants.setItalic    (m_Default, false);
    StyleConstants.setForeground(m_Default, Color.black);
    m_Default.addAttribute(FONT_ATTRIBUTE_KEY, new FontUIResource(getFont(m_Default)));
 
    /*-----------------------------------------------------*/
    /* Add the default attributes and the change listener. */
    /*-----------------------------------------------------*/
    s.addAttributes(m_Default);
    s.addChangeListener(new ChangeListener()
      {
      public void stateChanged(ChangeEvent e)
        {
        if (m_Restoring)
          return;
 
        Style s = (Style)e.getSource();
 
        synchronized(s)
          {
          m_Restoring = true;
          s.removeAttributes(s);
          s.addAttributes(m_Default);
          m_Restoring = false;
          }
        }
      });
    }
 
  /*****************************************************************************
  * updateDefault */
  /**
  * Updates the default style with an attribute set.
  *
  * @param  as  Attribute Set
  *****************************************************************************/
  public void updateDefault(AttributeSet as)
    {
    m_Default.addAttributes(as);
    getStyle(StyleContext.DEFAULT_STYLE).addAttributes(m_Default);
    }
  }

[Ilja Preuss]

Steve, thanks for the code!

I didn't yet take a close look, but should I ever need to touch that code again (which might in fact be in the near future), I will consider using it!