while (measurer.getPosition() < characterIterator.getEndIndex() && currentHeight <= boxHeight) { int previousPosition = measurer.getPosition(); layouts.add(layout); lastLine = text.substring(previousPosition, measurer.getPosition()); currentHeight += height;
LineBreakMeasurer measurer = new LineBreakMeasurer(it, graphics.getFontRenderContext()); for (;;) { int startIndex = measurer.getPosition(); int endIndex = measurer.getPosition();
frc); while (lbm.getPosition() < text.length()) { TextLayout tl = lbm.nextLayout(wrapWidth); textY += tl.getAscent();
public boolean hasNext() { if (currentMeasurer.getPosition() < currentText.length()) return true; else { currentIndex++; if (currentIndex < textParts.length) { currentMeasurer = measurers[currentIndex]; currentText = textParts[currentIndex]; return hasNext(); } else { return false; } } }
float remain = h; AttributedCharacterIterator newLineCheck = text.getIterator(); while (measure.getPosition() < textIter.getEndIndex()) { newLineCheck.setIndex(measure.getPosition()); char ch; while ((ch = newLineCheck.next()) != CharacterIterator.DONE) {
private WrappedLines breakLines(Graphics2D g) { Dimension size = label.getSize(); float maxWidth = size.width; AttributedString attributedText = new AttributedString(label.getText(), textAttributes()); AttributedCharacterIterator textIterator = attributedText.getIterator(); FontRenderContext fontRendering = g.getFontRenderContext(); LineBreakMeasurer measurer = new LineBreakMeasurer(textIterator, fontRendering); WrappedLines lines = new WrappedLines(); while(measurer.getPosition() < textIterator.getEndIndex()) { TextLayout layout = measurer.nextLayout(maxWidth); lines.add(layout); } return lines; }
while (measurer.getPosition() < charIterator.getEndIndex()) { measurer.setPosition(0); while (measurer.getPosition() < charIterator.getEndIndex()) { TextLayout textLayout = measurer.nextLayout(wrapWidth); float ascent = textLayout.getAscent();
public TextLayout next() { if (first) { first = false; } else { y += ascent * lineHeight; } double layoutWidth = width == 0 ? Float.MAX_VALUE : width; TextLayout layout = currentMeasurer.nextLayout((float) layoutWidth); if (width == 0) { layoutWidth = layout.getAdvance(); if (align == Align.RIGHT) { x = -layoutWidth; } else if (align == Align.CENTER) { x = -layoutWidth / 2.0; } } else if (align == Align.RIGHT) { x = width - layout.getAdvance(); } else if (align == Align.CENTER) { x = (width - layout.getAdvance()) / 2.0; } else if (align == Align.JUSTIFY) { // Don't justify the last line. if (currentMeasurer.getPosition() < currentText.length()) { layout = layout.getJustifiedLayout((float) width); } } ascent = layout.getAscent(); // y += layout.getDescent() + layout.getLeading() + layout.getAscent(); return layout; }
while (lineMeasurer.getPosition() < iter.getEndIndex()) { newPosition = lineMeasurer.getPosition(); } else { int nextBoundary = breaks.following(prevPosition);
public boolean hasNext() { return lineBreakMeasurer.getPosition() < ci.getEndIndex(); }
public LineBreakIteratorState next() { // For each line produced by the LinebreakMeasurer int start = lineBreakMeasurer.getPosition(); // float is the worst option to have accurate layouts. So we have to 'adjust' for rounding errors // and hope that no one notices .. TextLayout textLayout = lineBreakMeasurer.nextLayout( wrappingWidth + 0.5f, ci.getEndIndex(), false ); textLayout = postProcess( start, textLayout, lineBreakMeasurer ); int end = lineBreakMeasurer.getPosition(); // check if the text must be justified return new LineBreakIteratorState( textLayout, start, end ); }
protected TextLayout postProcess( final int start, final TextLayout textLayout, final LineBreakMeasurer lineBreakMeasurer ) { int end = lineBreakMeasurer.getPosition(); final TextLayout layout = performWordBreak( start, textLayout, lineBreakMeasurer, end ); return super.postProcess( start, layout, lineBreakMeasurer ); }
while (lineMeasurer.getPosition() < paragraphEnd) { TextLayout layout = lineMeasurer.nextLayout(maxTextWidth); layoutHeight += layout.getAscent() + layout.getDescent() + layout.getLeading(); while (lineMeasurer.getPosition() < paragraphEnd) { TextLayout layout = lineMeasurer.nextLayout(maxTextWidth); float posX = (float) pointAdjusted.x;
public MetaFont.GlyphVector[] createGlyphVectors(String s, int wrapWidth) { java.util.ArrayList rv = new java.util.ArrayList(); java.text.AttributedString attStr = new java.text.AttributedString(s); attStr.addAttribute(java.awt.font.TextAttribute.FONT, myFont); java.awt.font.LineBreakMeasurer lbm = new java.awt.font.LineBreakMeasurer(attStr.getIterator(), frc); int idx0 = 0; java.awt.font.TextLayout currLay = lbm.nextLayout(wrapWidth); while (currLay != null) { rv.add(new JavaGlyphVector(this, s.substring(idx0, lbm.getPosition()), currLay, frc)); idx0 = lbm.getPosition(); currLay = lbm.nextLayout(wrapWidth); } return (MetaFont.GlyphVector[]) rv.toArray(new MetaFont.GlyphVector[0]); }
/** Evaluate of the List of TextLayout objects corresponding * to this MText. Some things are approximations! */ private ArrayList<TextLayout> getLayouts(Graphics g) { ArrayList<TextLayout> layouts = new ArrayList<TextLayout>(); Graphics2D g2d = (Graphics2D) g; FontRenderContext frc = g2d.getFontRenderContext(); AttributedString attrStr = new AttributedString(text); attrStr.addAttribute(TextAttribute.FONT, font, 0, text.length()); LineBreakMeasurer measurer = new LineBreakMeasurer( attrStr.getIterator(), frc); float wrappingWidth; wrappingWidth = getSize().width - 15; while (measurer.getPosition() < text.length()) { TextLayout layout = measurer.nextLayout(wrappingWidth); layouts.add(layout); } return layouts; }
/** Called only if new TextLayouts are in need. * @param frc is used for possible new LineBreakMeasurer instance * @return current LineBreakMeasurer or <tt>null</tt> if no is available. */ private LineBreakMeasurer getMeasurer(FontRenderContext frc) { if (lineBreakMeasurer == null) { // first page to print lineBreakMeasurer = new LineBreakMeasurer(styledTexts[currentStyledText], frc); // no layouts available in this measurer? } else if (lineBreakMeasurer.getPosition() >= styledTexts[currentStyledText].getEndIndex()) { // next measurer is not available? if (currentStyledText == (styledTexts.length - 1)) { return null; // everything is printed } else { // use next styledTexts entry lineBreakMeasurer = new LineBreakMeasurer(styledTexts[++currentStyledText], frc); } } return lineBreakMeasurer; }
private void drawErrorText(String errStr, int w, Graphics2D g2) { g2.setColor(colorModel.getColor("alertColor")); g2.setFont(new Font(res.getString("g2_Font"), Font.BOLD, 20)); g2.drawString(res.getString("ERROR"), 5, 20); AttributedString as = new AttributedString(errStr); as.addAttribute(TextAttribute.FONT, font12, 0, errStr.length()); AttributedCharacterIterator aci = as.getIterator(); FontRenderContext frc = g2.getFontRenderContext(); LineBreakMeasurer lbm = new LineBreakMeasurer(aci, frc); float x = 5, y = 25; lbm.setPosition(0); while (lbm.getPosition() < errStr.length()) { TextLayout tl = lbm.nextLayout(w - x - 5); if (!tl.isLeftToRight()) { x = w - tl.getAdvance(); } tl.draw(g2, x, y += tl.getAscent()); y += tl.getDescent() + tl.getLeading(); } }
public void paint(Graphics g) { super.paintComponent(g); Graphics2D g2 = (Graphics2D) g; FontRenderContext frc = g2.getFontRenderContext(); LineBreakMeasurer measurer = new LineBreakMeasurer(m_iterator, frc); measurer.setPosition(m_start); float y = 0; while (measurer.getPosition() < m_end) { double ix = Math.sqrt((m_width / 2 - y) * y); float x = m_width / 2.0F - (float) ix; int width = (int) ix * 2; TextLayout layout = measurer.nextLayout(width); y += layout.getAscent(); float dx = layout.isLeftToRight() ? 0 : width - layout.getAdvance(); layout.draw(g2, x + dx, y); y += layout.getDescent() + layout.getLeading(); } }
// Create Font object with Font attribute (e.g. Font family, Font size, etc) for calculation java.awt.Font currFont = new java.awt.Font(fontName, 0, fontSize); AttributedString attrStr = new AttributedString(cellValue); attrStr.addAttribute(TextAttribute.FONT, currFont); // Use LineBreakMeasurer to count number of lines needed for the text FontRenderContext frc = new FontRenderContext(null, true, true); LineBreakMeasurer measurer = new LineBreakMeasurer(attrStr.getIterator(), frc); int nextPos = 0; int lineCnt = 0; while (measurer.getPosition() < cellValue.length()) { nextPos = measurer.nextOffset(mergedCellWidth); // mergedCellWidth is the max width of each line lineCnt++; measurer.setPosition(nextPos); } Row currRow = currSht.getRow(rowNum); currRow.setHeight((short)(currRow.getHeight() * lineCnt)); // The above solution doesn't handle the newline character, i.e. "\n", and only // tested under horizontal merged cells.
private static int countLines(JTextArea textArea) { AttributedString text = new AttributedString(textArea.getText()); text.addAttribute(TextAttribute.FONT, textArea.getFont()); FontRenderContext frc = textArea.getFontMetrics(textArea.getFont()).getFontRenderContext(); AttributedCharacterIterator charIt = text.getIterator(); LineBreakMeasurer lineMeasurer = new LineBreakMeasurer(charIt, frc); Insets textAreaInsets = textArea.getInsets(); float formatWidth = textArea.getWidth() - textAreaInsets.left - textAreaInsets.right; lineMeasurer.setPosition(charIt.getBeginIndex()); int noLines = 0; while (lineMeasurer.getPosition() < charIt.getEndIndex()) { lineMeasurer.nextLayout(formatWidth); noLines++; } return noLines; }