Scaling

[Richard West]

Hi everyone,

I have a JTextPane with some styled text in it and i am trying to scale them.

What i mean is that assuming that the text inside the JTextPane on startup is a 100% in size. After i click some JButton all the font size of the entire document is reduced to 25%

The thing is that this JTextPane contains alot of text that has different font sizes thus i want each of their respective font sizes of the character to be 25% of its original value.

Does anyone know how to do this?

But is there another way i could achieve the scaling of my styled text in my JTextPane so that it is 25% of its original value by means of subclassing my JTextPane or StyledDocument class and overiding its paint method?

Does anyone know how to do this?

Any help is greatly appreciated

Thank You

Yours Sincerely

Richard West

[Craig Wood]

import java.awt.*;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.text.*;
 
public class FontSizeTest
{
    Font bold, italic, normal;
    Style boldStyle, italicStyle, regularStyle;
 
    public FontSizeTest()
    {
        bold   = new Font("lucida sans regular",   Font.PLAIN, 18);
        italic = new Font("lucida bright italic",  Font.PLAIN, 18);
        normal = new Font("lucida bright regular", Font.PLAIN, 14);
    }
 
    private void scaleFonts(double scale)
    {
        StyleConstants.setFontSize(boldStyle,    (int)(bold.getSize()  *scale));
        StyleConstants.setFontSize(italicStyle,  (int)(italic.getSize()*scale));
        StyleConstants.setFontSize(regularStyle, (int)(normal.getSize()*scale));
    }
 
    /**
     * adapted from TextSamplerDemo in the tutorial
     */
    private JTextPane getTextPane()
    {
        String[] initString = {
            "A pool of styles and their associated resources. ",
            "This class determines the lifetime of a group of resources by being " +
                "a container that holds caches for various resources such as ",
            "font ",
            "and ",
            "color ",
            "that get reused by the various style definitions",
            ". This can be shared by multiple documents if desired to maximize " +
                "the sharing of related resources."
        };
        String[] initStyles = {
            "regular", "italic", "bold", "regular", "red", "underline", "regular"
        };
 
        JTextPane textPane = new JTextPane()
        {
            protected void paintComponent(Graphics g)
            {
                Graphics2D g2 = (Graphics2D)g;
                g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                                    RenderingHints.VALUE_ANTIALIAS_ON);
                super.paintComponent(g);
            }
        };
        StyledDocument doc = textPane.getStyledDocument();
        addStylesToDocument(doc);
 
        try
        {
            for(int j = 0; j < initString.length; j++)
                doc.insertString(doc.getLength(), initString[j],
                                 doc.getStyle(initStyles[j]));
        }
        catch(BadLocationException ble)
        {
            System.err.println("insertion bad location: " + ble.getMessage());
        }
        return textPane;
    }
 
    /**
     * adapted from TextSamplerDemo in the tutorial
     */
    protected void addStylesToDocument(StyledDocument doc)
    {
        // create reference into default style context for document
        Style defaultStyle = StyleContext.getDefaultStyleContext()
                                 .getStyle(StyleContext.DEFAULT_STYLE);
 
        // init named parent styles
        regularStyle = doc.addStyle("", defaultStyle);
        StyleConstants.setFontFamily(regularStyle , normal.getFontName());
 
        italicStyle = doc.addStyle("", defaultStyle);
        StyleConstants.setFontFamily(italicStyle, italic.getFontName());
 
        boldStyle = doc.addStyle("", defaultStyle);
        StyleConstants.setFontFamily(boldStyle, bold.getFontName());
 
        // add styles and attributes for names defined in 'initStyles'
        Style s = doc.addStyle("regular", regularStyle);
        StyleConstants.setFontSize(regularStyle , normal.getSize());
 
        s = doc.addStyle("italic", italicStyle);
        StyleConstants.setFontSize(italicStyle, italic.getSize());
        StyleConstants.setItalic(italicStyle, true);
 
        s = doc.addStyle("bold", boldStyle);
        StyleConstants.setFontSize(boldStyle, bold.getSize());
        StyleConstants.setBold(boldStyle, true);
 
        s = doc.addStyle("red", regularStyle);
        StyleConstants.setForeground(s, Color.red);
 
        s = doc.addStyle("underline", regularStyle);
        StyleConstants.setUnderline(s, true);
    }
 
    private JComponent getUIPanel()
    {
        final JSlider slider = new JSlider(JSlider.HORIZONTAL, 50, 200, 100);
        slider.setPaintLabels(true);
        slider.setMinorTickSpacing(10);
        slider.setMajorTickSpacing(50);
        slider.setPaintTicks(true);
        slider.addChangeListener(new ChangeListener()
        {
            public void stateChanged(ChangeEvent e)
            {
                JSlider slider = (JSlider)e.getSource();
                double percent = slider.getValue()/100.0;
                scaleFonts(percent);
            }
        });
        JComponent box = Box.createHorizontalBox();
        box.setBorder(BorderFactory.createTitledBorder("font size percentage"));
        box.add(slider);
        return box;
    }
 
    public static void main(String[] args)
    {
        FontSizeTest test = new FontSizeTest();
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.getContentPane().add(test.getUIPanel(), "North");
        f.getContentPane().add(new JScrollPane(test.getTextPane()));
        f.setSize(400,400);
        f.setLocation(200,200);
        f.setVisible(true);
    }
}

[Richard West]

Hi everyone,

I tried adopting you way and tried to it but the program does not seem to work.

Here is a full compilable example where you can compile the code and see what i mean

import java.awt.*;
import java.util.*;
import java.awt.geom.*;
import javax.swing.*;
import javax.swing.text.*;
 
public class JTextScalar
 
{
JFrame fr = new JFrame ("Frame"); 
 
JScalableTextPane TextPane1 = new JScalableTextPane();
 
StyleContext sc = new StyleContext();
 
DefaultStyledDocument dse = new DefaultStyledDocument(sc);
 
JScrollPane ScrollPane1 = new JScrollPane(TextPane1, ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS, 
ScrollPaneConstants.HORIZONTAL_SCROLLBAR_ALWAYS);
 
StyledEditorKit StyledEditorKit1 = new StyledEditorKit();                                        
 
JViewport viewport;
 
public void initialize()
{ 
Container pane = fr.getContentPane();
pane.setLayout(new BorderLayout());
fr.setSize(250,300);
fr.setLocation(300,300);
fr.setBackground(Color.lightGray);
 
dse.putProperty("i18n", Boolean.TRUE);
 
TextPane1.setEditorKit(StyledEditorKit1);
 
//The below command line sets the document that the JTextPane will be 
//be referencing to
 
TextPane1.setDocument(dse);
 
viewport = new JViewport();
viewport.setView(TextPane1);
viewport.setScrollMode(viewport.SIMPLE_SCROLL_MODE); 
//viewport.setScrollMode(viewport.BACKINGSTORE_SCROLL_MODE);
ScrollPane1.setViewport(viewport);
 
pane.add("Center", ScrollPane1);
//ScrollPane1.invalidate(); 
ScrollPane1.revalidate(); 
ScrollPane1.repaint(); 
TextPane1.revalidate(); 
TextPane1.repaint(); 
 
fr.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
fr.pack();
fr.setVisible(true);
}
 
public static void main(String args[])
{
JTextScalar a = new JTextScalar(); 
a.initialize();
}
}
 
class JScalableTextPane extends JTextPane
 
{
/*
public void paintComponent(Graphics g)
{
//This function overrides the JPanel paintComponent function
//and paints the buffered image on the JPEGPanel 
 
Graphics2D g2d = (Graphics2D)g;
g2d.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS,
                     RenderingHints.VALUE_FRACTIONALMETRICS_ON);
 
g2d.scale(0.5, 0.5);
//AffineTransform old = g2d.getTransform();
//g2d.setTransform(old);
//super.notify();
//super.revalidate();
//super.repaint();
super.paintComponent(g2d);
}
*/
public void paint(Graphics g) 
{
Graphics2D g2d = (Graphics2D)g;
g2d.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS,
RenderingHints.VALUE_FRACTIONALMETRICS_ON);
 
g2d.scale(0.5,0.5);
AffineTransform old = g2d.getTransform();
g2d.setTransform(old);
super.paint(g2d);
}
 
public Dimension getPreferredSize() 
{
Dimension d= super.getPreferredSize();
d.setSize(d.width*0.5,d.height*0.5);   
return d;
} 
 
public Dimension getMinimumSize () 
{
Dimension d= super.getMinimumSize ();
d.setSize(d.width*0.5,d.height*0.5);   
return d;
}
 
public Dimension getMaximumSize () 
{
Dimension d= super.getMaximumSize();
d.setSize(d.width*0.5,d.height*0.5);   
return d;
}
 
public Dimension getSize () 
{
Dimension d= super.getSize ();
d.setSize(d.width*0.5,d.height*0.5);   
return d;
}
 
}

The thing is that the text is scaled corretly but ScrollPane screws up completely and the typing of the text is not accurate

Is the way i am scaling the JTextpane correct?

Any help is greatly appreciated

Thank You

Yours Sincerely

Richard West

[Craig Wood]

What you are doing with the various 'getXXXSize' methods is changing the size of the
JTextPane which will have an affect on the JScrollPane. In the 'setTransform' call in the
'paint' method you are scaling the entire rendering of the JTextPane by the scale factor.
This is just like taking a photo of it and scaling it: text, borders, scrollBars ...
everything is scaled. The 'paint' method is called to render the JTextPane component.
Setting a transform for its graphics context affects everything in the rendering.

From reading your original question/intent this does not seem to be what you want. I think
you want the JTextPane to appear at its normal size and the font sizes of all styled text
to change by a uniform scale factor. If this is so then I can see two ways of doing this.
The first is to save references to the parent Style objects as you create them and use
these to change the font sizes by your scale factor. I tried to illustrate this in
FontSizeTest.

The second way is to not save any references to the styles you set in the document at
construction. When you are ready for scaling you get the document, enumerate through the
styles in it, identify the ones that have a font size attribute and reset the attribute
with the newly scaled size. This approach is a little more general and flexible than the
first.

Trying to do this inside some kind of paint/rendering code may require some extensive
research into the source code for JTextPane and the plaf classes that it uses for
rendering.

[Richard West]

Hi everyone,

I think you want the JTextPane to appear at its normal size and the font sizes of all styled text to change by a uniform scale factor.

Yes this exactly what i want to do

The second way is to not save any references to the styles you set in the document at construction. When you are ready for scaling you get the document, enumerate through the styles in it, identify the ones that have a font size attribute and reset the attribute with the newly scaled size.

I think the second way suits most of my needs but if it is of no inconvinience to you could you post a little sample on how to enumenrate through the document and find font size attribute and change i to the scaled value.

I have a little issue that i am also worried about in that the font size attribute take in an integer but when i get the scaling factor it will be a double. Yes i can cast it to an integer but would that not cause a lost of precision that could have huge effects on what i am doing?

I really appreciate that you are taking this time to answer my question
craig wood

Any help is greatly appreciated

Thank You

Yours Sincerely

Richard West

[Craig Wood]

import java.awt.*;
import java.awt.event.*;
import java.util.Enumeration;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.text.*;
 
public class StyleTest
{
    JTextPane textPane;
 
    private void adjustFontAttributes(int inc)
    {
        DefaultStyledDocument doc =
               (DefaultStyledDocument)textPane.getStyledDocument();
        Enumeration e = doc.getStyleNames();
        while(e.hasMoreElements())
        {
            String name = (String)e.nextElement();
            Style style = doc.getStyle(name);
            if(style.isDefined(StyleConstants.FontSize))
            {
                int size =
                    ((Integer)style.getAttribute(StyleConstants.FontSize)).intValue();
                StyleConstants.setFontSize(style, size + inc);
                //System.out.println("name = " + name + "\t" +
                //                   "fontSize = " + 
                //                   style.getAttribute(StyleConstants.FontSize));
            }
        }
    }
 
    /**
     * adapted from <a href="http://javaalmanac.com/egs/javax.swing.text/style_ModStyle.html" target="_blank" rel="nofollow">Automatically Updating Styled Text When a Style Is Updated</a>
     */
    private void resetStyle(Style style)
    {
        StyledDocument doc = textPane.getStyledDocument();
        Element sectionElem = doc.getDefaultRootElement();
        int paraCount = sectionElem.getElementCount();
        for(int j = 0; j < paraCount; j++)
        {
            Element paraElem = sectionElem.getElement(j);
            AttributeSet attr = paraElem.getAttributes();
            String attrName = (String)attr.getAttribute(StyleConstants.NameAttribute);
            if(style.getName().equals(attrName))
            {
                int offset = paraElem.getStartOffset();
                int end    = paraElem.getEndOffset();
                int length = end - offset;
                doc.setParagraphAttributes(offset, length, style, true);
            }
            for(int k = 0; k < paraElem.getElementCount(); k++)
            {
                Element contentElem = paraElem.getElement(k);
                attr = contentElem.getAttributes();
                attrName = (String)attr.getAttribute(StyleConstants.NameAttribute);
                if(style.getName().equals(attrName))
                {
                    int offset = contentElem.getStartOffset();
                    int end    = contentElem.getEndOffset();
                    int length = end - offset;
                    doc.setCharacterAttributes(offset, length, style, true);
                }
            }
        }
    }
 
    /**
     * adapted from TextSamplerDemo in the tutorial
     */
    private JTextPane getTextPane()
    {
        String[] initString = {
            "A pool of styles and their associated resources. ",
            "This class determines the lifetime of a group of resources by being " +
                "a container that holds caches for various resources such as ",
            "font ",
            "and ",
            "color ",
            "that get reused by the various style definitions",
            ". This can be shared by multiple documents if desired to maximize " +
                "the sharing of related resources."
        };
        String[] initStyles = {
            "normal", "italic", "bold", "normal", "red", "underline", "normal"
        };
 
        textPane = new JTextPane()
        {
            protected void paintComponent(Graphics g)
            {
                Graphics2D g2 = (Graphics2D)g;
                g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                                    RenderingHints.VALUE_ANTIALIAS_ON);
                super.paintComponent(g);
            }
        };
        StyledDocument doc = textPane.getStyledDocument();
        addStylesToDocument(doc);
 
        try
        {
            for(int j = 0; j < initString.length; j++)
                doc.insertString(doc.getLength(), initString[j],
                                 doc.getStyle(initStyles[j]));
        }
        catch(BadLocationException ble)
        {
            System.err.println("insertion bad location: " + ble.getMessage());
        }
        return textPane;
    }
 
    /**
     * adapted from TextSamplerDemo in the tutorial
     */
    protected void addStylesToDocument(StyledDocument doc)
    {
        Font 
            bold   = new Font("lucida sans regular",   Font.PLAIN, 18),
            italic = new Font("lucida bright italic",  Font.PLAIN, 18),
            normal = new Font("lucida bright regular", Font.PLAIN, 14);
         ChangeListener l = new ChangeListener()
        {
            public void stateChanged(ChangeEvent e)
            {
                Style style = (Style)e.getSource();
                resetStyle(style);
            }
        };
 
        // create reference into default style context for document
        Style defaultStyle = StyleContext.getDefaultStyleContext()
                                 .getStyle(StyleContext.DEFAULT_STYLE);
 
        // add  styles and attributes to document
        Style s = doc.addStyle("normal", defaultStyle);
        s.addChangeListener(l);
        StyleConstants.setFontFamily(s , normal.getFontName());
        StyleConstants.setFontSize(s , normal.getSize());
 
        s = doc.addStyle("italic", defaultStyle);
        s.addChangeListener(l);
        StyleConstants.setFontFamily(s, italic.getFontName());
        StyleConstants.setFontSize(s, italic.getSize());
        StyleConstants.setItalic(s, true);
 
        s = doc.addStyle("bold", defaultStyle);
        s.addChangeListener(l);
        StyleConstants.setFontFamily(s, bold.getFontName());
        StyleConstants.setFontSize(s, bold.getSize());
        StyleConstants.setBold(s, true);
 
        s = doc.addStyle("red", defaultStyle);
        StyleConstants.setForeground(s, Color.red);
 
        s = doc.addStyle("underline", defaultStyle);
        StyleConstants.setUnderline(s, true);
    }
 
    private JComponent getUIPanel()
    {
        final JButton
            smaller = new JButton("smaller"),
            larger  = new JButton("larger");
        ActionListener l = new ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            {
                JButton button = (JButton)e.getSource();
                int inc = 0;
                if(button == smaller)
                    inc = -1;
                if(button == larger)
                    inc = 1;
                adjustFontAttributes(inc);
            }
        };
        smaller.addActionListener(l);
        larger.addActionListener(l);
        JComponent box = Box.createHorizontalBox();
        box.add(Box.createHorizontalGlue());
        box.add(smaller);
        box.add(Box.createHorizontalGlue());
        box.add(larger);
        box.add(Box.createHorizontalGlue());
        return box;
    }
 
    public static void main(String[] args)
    {
        StyleTest test = new StyleTest();
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.getContentPane().add(test.getUIPanel(), "North");
        f.getContentPane().add(new JScrollPane(test.getTextPane()));
        f.setSize(400,400);
        f.setLocation(200,200);
        f.setVisible(true);
    }
}