@Override
public Dimension getMinimumSize(int cols) {
Font f = xtext.getFont();
FontMetrics fm = xtext.getFontMetrics(f);
return new Dimension(
fm.charWidth('0') * cols + 10, fm.getMaxDescent() + fm.getMaxAscent() + PADDING);
}
@Override
public void setFont(Font font) {
FontMetrics fm = getFontMetrics(font);
lineHeight = fm.getHeight();
charWidth = fm.charWidth('0');
super.setFont(font);
}
/** Calculate the width needed to display the maximum line number */
private void setPreferredWidth() {
Element root = component.getDocument().getDefaultRootElement();
int lines = root.getElementCount();
int digits = Math.max(String.valueOf(lines).length(), minimumDisplayDigits);
// Update sizes when number of digits in the line number changes
if (lastDigits != digits) {
lastDigits = digits;
FontMetrics fontMetrics = getFontMetrics(getFont());
int width = fontMetrics.charWidth('0') * digits;
Insets insets = getInsets();
int preferredWidth = insets.left + insets.right + width;
Dimension d = getPreferredSize();
d.setSize(preferredWidth, HEIGHT);
setPreferredSize(d);
setSize(d);
}
}
private void setTabSize(int charactersPerTab) {
FontMetrics fm = this.getFontMetrics(this.getFont());
int charWidth = fm.charWidth('w');
int tabWidth = charWidth * charactersPerTab;
TabStop[] tabs = new TabStop[10];
for (int j = 0; j < tabs.length; j++) {
int tab = j + 1;
tabs[j] = new TabStop(tab * tabWidth);
}
TabSet tabSet = new TabSet(tabs);
SimpleAttributeSet attributes = new SimpleAttributeSet();
StyleConstants.setFontSize(attributes, 18);
StyleConstants.setFontFamily(attributes, "Osaka-Mono");
StyleConstants.setTabSet(attributes, tabSet);
int length = getDocument().getLength();
getStyledDocument().setParagraphAttributes(0, length, attributes, true);
}
private static boolean isMonospaced(FontMetrics fontMetrics) {
boolean isMonospaced = true;
int charWidth = -1;
for (int codePoint = 0; codePoint < 128; codePoint++) {
if (Character.isValidCodePoint(codePoint)) {
char character = (char) codePoint;
if (isWordCharacter(character)) {
int w = fontMetrics.charWidth(character);
if (charWidth != -1) {
if (w != charWidth) {
isMonospaced = false;
break;
}
} else {
charWidth = w;
}
}
}
}
return isMonospaced;
}
private void establishFontMetrics() {
final BufferedImage img = createBufferedImage(1, 1);
final Graphics2D graphics = img.createGraphics();
graphics.setFont(myNormalFont);
final float lineSpace = mySettingsProvider.getLineSpace();
final FontMetrics fo = graphics.getFontMetrics();
myDescent = fo.getDescent();
myCharSize.width = fo.charWidth('W');
myCharSize.height = fo.getHeight() + (int) (lineSpace * 2);
myDescent += lineSpace;
myMonospaced = isMonospaced(fo);
if (!myMonospaced) {
LOG.info("WARNING: Font " + myNormalFont.getName() + " is non-monospaced");
}
img.flush();
graphics.dispose();
}
/**
* Converts an x co-ordinate to an offset within a line.
*
* @param line The line
* @param x The x co-ordinate
*/
public int xToOffset(int line, int x) {
TokenMarker tokenMarker = getTokenMarker();
/* Use painter's cached info for speed */
FontMetrics fm = painter.getFontMetrics();
getLineText(line, lineSegment);
char[] segmentArray = lineSegment.array;
int segmentOffset = lineSegment.offset;
int segmentCount = lineSegment.count;
int width = horizontalOffset;
if (tokenMarker == null) {
for (int i = 0; i < segmentCount; i++) {
char c = segmentArray[i + segmentOffset];
int charWidth;
if (c == '\t') charWidth = (int) painter.nextTabStop(width, i) - width;
else charWidth = fm.charWidth(c);
if (painter.isBlockCaretEnabled()) {
if (x - charWidth <= width) return i;
} else {
if (x - charWidth / 2 <= width) return i;
}
width += charWidth;
}
return segmentCount;
} else {
Token tokens;
if (painter.currentLineIndex == line && painter.currentLineTokens != null)
tokens = painter.currentLineTokens;
else {
painter.currentLineIndex = line;
tokens = painter.currentLineTokens = tokenMarker.markTokens(lineSegment, line);
}
int offset = 0;
Toolkit toolkit = painter.getToolkit();
Font defaultFont = painter.getFont();
SyntaxStyle[] styles = painter.getStyles();
for (; ; ) {
byte id = tokens.id;
if (id == Token.END) return offset;
if (id == Token.NULL) fm = painter.getFontMetrics();
else fm = styles[id].getFontMetrics(defaultFont);
int length = tokens.length;
for (int i = 0; i < length; i++) {
char c = segmentArray[segmentOffset + offset + i];
int charWidth;
if (c == '\t') charWidth = (int) painter.nextTabStop(width, offset + i) - width;
else charWidth = fm.charWidth(c);
if (painter.isBlockCaretEnabled()) {
if (x - charWidth <= width) return offset + i;
} else {
if (x - charWidth / 2 <= width) return offset + i;
}
width += charWidth;
}
offset += length;
tokens = tokens.next;
}
}
}
/**
* The constructor for this class has a bunch of arguments: The frame argument is required for all
* printing in Java. The jobname appears left justified at the top of each printed page. The font
* size is specified in points, as on-screen font sizes are. The margins are specified in inches
* (or fractions of inches).
*/
public HardcopyWriter(
Frame frame,
String jobname,
int fontsize,
double leftmargin,
double rightmargin,
double topmargin,
double bottommargin)
throws HardcopyWriter.PrintCanceledException {
// Get the PrintJob object with which we'll do all the printing.
// The call is synchronized on the static printprops object, which
// means that only one print dialog can be popped up at a time.
// If the user clicks Cancel in the print dialog, throw an exception.
Toolkit toolkit = frame.getToolkit(); // get Toolkit from Frame
synchronized (printprops) {
job = toolkit.getPrintJob(frame, jobname, printprops);
}
if (job == null) throw new PrintCanceledException("User cancelled print request");
pagesize = job.getPageDimension(); // query the page size
pagedpi = job.getPageResolution(); // query the page resolution
// Bug Workaround:
// On windows, getPageDimension() and getPageResolution don't work, so
// we've got to fake them.
if (System.getProperty("os.name").regionMatches(true, 0, "windows", 0, 7)) {
// Use screen dpi, which is what the PrintJob tries to emulate, anyway
pagedpi = toolkit.getScreenResolution();
System.out.println(pagedpi);
// Assume a 8.5" x 11" page size. A4 paper users have to change this.
pagesize = new Dimension((int) (8.5 * pagedpi), 11 * pagedpi);
System.out.println(pagesize);
// We also have to adjust the fontsize. It is specified in points,
// (1 point = 1/72 of an inch) but Windows measures it in pixels.
fontsize = fontsize * pagedpi / 72;
System.out.println(fontsize);
System.out.flush();
}
// Compute coordinates of the upper-left corner of the page.
// I.e. the coordinates of (leftmargin, topmargin). Also compute
// the width and height inside of the margins.
x0 = (int) (leftmargin * pagedpi);
y0 = (int) (topmargin * pagedpi);
width = pagesize.width - (int) ((leftmargin + rightmargin) * pagedpi);
height = pagesize.height - (int) ((topmargin + bottommargin) * pagedpi);
// Get body font and font size
font = new Font("Monospaced", Font.PLAIN, fontsize);
metrics = toolkit.getFontMetrics(font);
lineheight = metrics.getHeight();
lineascent = metrics.getAscent();
charwidth = metrics.charWidth('0'); // Assumes a monospaced font!
// Now compute columns and lines will fit inside the margins
chars_per_line = width / charwidth;
lines_per_page = height / lineheight;
// Get header font information
// And compute baseline of page header: 1/8" above the top margin
headerfont = new Font("SansSerif", Font.ITALIC, fontsize);
headermetrics = toolkit.getFontMetrics(headerfont);
headery = y0 - (int) (0.125 * pagedpi) - headermetrics.getHeight() + headermetrics.getAscent();
// Compute the date/time string to display in the page header
DateFormat df = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.SHORT);
df.setTimeZone(TimeZone.getDefault());
time = df.format(new Date());
this.jobname = jobname; // save name
this.fontsize = fontsize; // save font size
}
