lib.terminalemulator/src/org/netbeans/lib/terminalemulator/Buffer.java - netbeans - Git at Google

 /**
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */

 /*
  * "Buffer.java"
  * Buffer.java 1.8 01/07/30
  */
 package org.netbeans.lib.terminalemulator;

 import java.util.Vector;

 /**
  * The Buffer used by Term is _not_ related to javax.swing.text.Document.
  * <p>
  * The Swing Document is Element based while terms is Line based.
  * <br>
  * The Swing Document uses offsets for coordinates, while term uses cartesian
  * BCoords.
  * <p>
  */
 class Buffer {

     /*
      * For some odd reason Vector.removeRange is protected, so
      * we have to do this to gain access to it.
      */
     private static class OurVector<T> extends Vector<T> {

         @Override
         public void removeRange(int fromIndex, int toIndex) {
             super.removeRange(fromIndex, toIndex);
         }
     }
     private final OurVector<Line> lines = new OurVector<>();	// buffer

     // How is this different from lines.length?
     private int nlines;		// number of lines in buffer

     private int visible_cols;	// number of columns visible in view
     private int extra_cols;	// columns needed to support lines longer
     				// than visible_cols. Only grows.

     /**
      * @return nlines
      */
     int nlines() {
 	return nlines;
     }

     public int visibleCols() {
         return visible_cols;
     }

     public int totalCols() {
         return visible_cols + extra_cols;
     }

     public Buffer(int visible_cols) {
         this.visible_cols = visible_cols;
     }

     public void setVisibleCols(int visible_cols) {
         int delta = visible_cols - this.visible_cols;
         this.visible_cols = visible_cols;
         extra_cols -= delta;
         if (extra_cols < 0) {
             extra_cols = 0;
         }
     }

     /*
      * Keep track of the largest column # to help set the extent of
      * the horizontal scrollbar.
      */
     public void noteColumn(int col) {
         int new_extra = col - visible_cols;
         if (new_extra > extra_cols) {
             extra_cols = new_extra;
         // LATER hrange_listener.adjustHRange(extra_cols);
         }
     }

     /* DEBUG
     public static volatile boolean lock = false;

     private void ck_lock() {
     if (lock) {
     System.out.println("Buffer ck_lock fail");	// NOI18N
     printStats();
     Thread.dumpStack();
     }
     }
      */
     Line lineAt(int brow) {
         try {
             return lines.elementAt(brow);
         } catch (ArrayIndexOutOfBoundsException x) {
             //XXX swallowing this exception caused issue 40129.
             //I've put in a null-check on the return value in sel.paint()
             //as a hotfix.  Should find out why bad values are being passed
             //here.  Ivan?

             /* DEBUG
             System.out.println("Buffer.lineAt(" +brow+ ") -> null\n");// NOI18N
             Thread.dumpStack();
              */
             return null;
         }
     }

     Line bottom() {
         return lineAt(nlines);
     }

     public Line appendLine() {
         // DEBUG ck_lock();
         Line l = new Line();
         lines.add(l);
         nlines++;
         return l;
     }

     public Line addLineAt(int row) {
         // DEBUG ck_lock();
         Line l = new Line();
         lines.add(row, l);
         nlines++;
         return l;
     }

     /**
      * Remove 'n' lines starting at 'row'.
      * Return the number of characters deleted as a result.
      */
     public int removeLinesAt(int row, int n) {
         // DEBUG ck_lock();
         int nchars = 0;
         for (int r = row; r < row + n; r++) {
             nchars += lineAt(r).length() + 1;
         }

         lines.removeRange(row, row + n);
         nlines -= n;

         return nchars;
     }

     public void removeLineAt(int row) {
         // DEBUG ck_lock();
         lines.remove(row);
         nlines--;
     }

     public Line moveLineFromTo(int from, int to) {
         // DEBUG ck_lock();
         Line l = lines.remove(from);
         lines.add(to, l);
         return l;
     }

     /**
      * Visit the physical lines from 'begin', through 'end'.
      * <p>
      * If 'newlines' is set, the passed 'ecol' is set to the actual
      * number of columns in the view to signify that the newline is included.
      * This way of doing it helps with rendering of a whole-line selection.
      * Also Line knows about this and will tack on a "\n" when Line.text()
      * is asked for.
      */
     void visitLines(BCoord begin, BCoord end, boolean newlines,
             LineVisitor visitor) {

         // In the general case a range is made up of three
         // rectangles. The partial line at top, the partial line
         // at the bottom and the middle range of fully selected lines.

         Line l;
         if (begin.row == end.row) {
             // range is on one line
             l = lineAt(begin.row);
             visitor.visit(l, begin.row, begin.col, end.col);

         } else {
             boolean cont;

             // range spans multiple lines
             l = lineAt(begin.row);
             if (newlines && !l.isWrapped()) {
                 cont = visitor.visit(l, begin.row, begin.col, totalCols());
             } else {
                 cont = visitor.visit(l, begin.row, begin.col, l.length() - 1);
             }
             if (!cont) {
                 return;
             }

             for (int r = begin.row + 1; r < end.row; r++) {
                 l = lineAt(r);
                 if (newlines && !l.isWrapped()) {
                     cont = visitor.visit(l, r, 0, totalCols());
                 } else {
                     cont = visitor.visit(l, r, 0, l.length() - 1);
                 }
                 if (!cont) {
                     return;
                 }
             }

             l = lineAt(end.row);
             cont = visitor.visit(l, end.row, 0, end.col);
             if (!cont) {
                 return;
             }
         }
     }

     /*
      * Like visitLines() except in reverse.
      * <p>
      * Starts at 'end' and goes to 'begin'.
      */
     void reverseVisitLines(BCoord begin, BCoord end, boolean newlines,
             LineVisitor visitor) {

         // very similar to visitLines

         Line l;
         if (begin.row == end.row) {
             // range is on one line
             l = lineAt(begin.row);
             visitor.visit(l, begin.row, begin.col, end.col);

         } else {
             boolean cont;

             // range spans multiple lines
             l = lineAt(end.row);
             cont = visitor.visit(l, end.row, 0, end.col);
             if (!cont) {
                 return;
             }

             for (int r = end.row - 1; r > begin.row; r--) {
                 l = lineAt(r);
                 if (newlines && !l.isWrapped()) {
                     cont = visitor.visit(l, r, 0, totalCols());
                 } else {
                     cont = visitor.visit(l, r, 0, l.length() - 1);
                 }
                 if (!cont) {
                     return;
                 }
             }

             l = lineAt(begin.row);
             if (newlines && !l.isWrapped()) {
                 cont = visitor.visit(l, begin.row, begin.col, totalCols());
             } else {
                 cont = visitor.visit(l, begin.row, begin.col, l.length() - 1);
             }
             if (!cont) {
                 return;
             }
         }
     }

     public BExtent find_line(BCoord coord) {
         WordDelineator newLine = WordDelineator.createNewlineDelineator();
         return find_word(newLine, coord);
     }

     public BExtent find_word(WordDelineator word_delineator, BCoord coord) {
         /*
          * Find the boundaries of a "word" at 'coord'.
          */

         int row = coord.row;
         Line startLine = lineAt(row);

         if (coord.col >= startLine.length()) {
             return new BExtent(coord, coord);
         }

         int lx = 0;
         int rx = 0;
         int beginRow = row;
         int endRow = row;
         StringBuffer lineBuffer;

         // Try to use lineVisitor
         while (beginRow >= 0) {
             Line line = lineAt(beginRow);
             lineBuffer = line.stringBuffer();
             int searchCol = (lx == -1) ? line.length() - 1 : coord.col;
             lx = word_delineator.findLeft(lineBuffer, searchCol, true);

             if (lx != -1) {
                 break;
             } else {
                 if (beginRow == 0) {
                     lx = 0;
                 } else if (!lineAt(beginRow - 1).isWrapped()) {
                     lx = 0;
                     break;
                 }
             }
             beginRow--;
         }
         while (endRow < nlines) {
             Line line = lineAt(endRow);
             lineBuffer = line.stringBuffer();
             int searchCol = (rx == -1) ? 0 : coord.col;
             rx = word_delineator.findRight(lineBuffer, searchCol, true);

             if (rx != -1) {
                 break;
             } else {
                 if (endRow == nlines - 1) {
                     rx = line.length() - 1;
                 }
                 if (!line.isWrapped()) {
                     rx = line.length() - 1;
                     break;
                 }
             }
             endRow++;
         }

         return new BExtent(new BCoord(beginRow, lx),
                 new BCoord(endRow, rx));
     }

     /**
      * Back up the coordinate by one character and return new BCoord
      * <p>
      * Travels back over line boundaries
      * <br>
      * Returns null if 'c' is the first character of the buffer.
      */
     public BCoord backup(BCoord c) {
         if (c.col > 0) {
             return new BCoord(c.row, c.col - 1);	// back one in line
         }
         // Cursor is at beginning of line.
         // Need to find the end of previous line, but it might empty,
         // so we go one line back etc
         for (int prevrow = c.row - 1; prevrow >= 0; prevrow--) {
             Line l = lineAt(prevrow);
             if (l.length() != 0) {
                 return new BCoord(prevrow, l.length() - 1);
             }
         }

         // prevrow == -1, at beginning of file; nowhere to back to
         return null;
     }

     /*
      * Advance the coordinate by one character and return a new coord.
      * <p>
      * Wraps around line boundaries.
      * <br>
      * Returns null if 'c' is at the last character of the buffer.
      */
     @SuppressWarnings("ValueOfIncrementOrDecrementUsed")
     public BCoord advance(BCoord c) {
         int row = c.row;
         int col = c.col;

         col++;
         Line l = lineAt(row);
         if (col < l.length()) {
             return new BCoord(row, col);
         }

         // Need to wrap, but the next line might be empty ... so we
         // keep going til either we find a non-empty line or the end
         // of the buffer.
         while (++row < nlines) {
             l = lineAt(row);
             if (l.length() != 0) {
                 return new BCoord(row, 0);
             }
         }
         return null;
     }

     private int utilization(int nchars, int ncapacity) {
         float u = ((float) nchars) / ((float) ncapacity);
         float p = u * 100.0f;      // convert to percentage
         return (int) p;
     }
     /*
      * Print interesting statistics and facts about this Term
      */

     public void printStats(boolean indented) {
         int chars = 0;
         int charcapacity = 0;

         int nalines = 0;     // lines with attributes
         int attrs = 0;
         int attrcapacity = 0;

         for (int lx = 0; lx < nlines; lx++) {
             Line l = lineAt(lx);
             chars += l.length();
             charcapacity += l.capacity();
             if (l.hasAttributes()) {
                 nalines++;
                 attrs += l.length();
                 attrcapacity += l.capacity();
             }
         }

         Term.indent(indented);
         System.out.println("Buffer:" + // NOI18N
                 "  nlines " + nlines);	// NOI18N

         Term.indent(indented);
         System.out.println("       " + // NOI18N
                 "  chars " + chars + // NOI18N
                 "  charcapacity " + charcapacity + // NOI18N
                 "  utilzn %" + utilization(chars, charcapacity));	// NOI18N

         Term.indent(indented);
         System.out.println("       " + // NOI18N
                 "  attrs " + attrs + // NOI18N
                 "  attrcapacity " + attrcapacity + // NOI18N
                 "  utilzn %" + utilization(attrs, attrcapacity));	// NOI18N

         // estimate actual byte consumption
         final int unitObjectSz = 8;
         final int unitReferenceSz = 4;

         final int unitBooleanSz = 4;
         final int unitCharSz = 2;
         final int unitIntSz = 4;

         final int unitCharArraySz = 12;
         final int unitIntArraySz = 12;

         long bytes = 0;
         long unitLineSz = unitObjectSz +
                 unitBooleanSz + // about_to_wrap
                 unitReferenceSz + // attr
                 unitIntSz + // backgroundColor
                 unitReferenceSz + // buf
                 unitIntSz + // capacity
                 unitIntSz + // glyphId
                 unitIntSz + // length
                 unitBooleanSz // wrapped
                 ;
         bytes += unitLineSz * nlines;

         bytes += unitCharArraySz * nlines;
         bytes += unitCharSz * charcapacity;

         bytes += unitIntArraySz * nalines;
         bytes += unitIntSz * attrcapacity;

         Term.indent(indented);
         System.out.println("       " + // NOI18N
                 "  bytes " + bytes / 1024 + "K");         	// NOI18N

     }
 }
	/**
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/

	/*
	* "Buffer.java"
	* Buffer.java 1.8 01/07/30
	*/
	package org.netbeans.lib.terminalemulator;

	import java.util.Vector;

	/**
	* The Buffer used by Term is _not_ related to javax.swing.text.Document.
	* <p>
	* The Swing Document is Element based while terms is Line based.
	* <br>
	* The Swing Document uses offsets for coordinates, while term uses cartesian
	* BCoords.
	* <p>
	*/
	class Buffer {

	/*
	* For some odd reason Vector.removeRange is protected, so
	* we have to do this to gain access to it.
	*/
	private static class OurVector<T> extends Vector<T> {

	@Override
	public void removeRange(int fromIndex, int toIndex) {
	super.removeRange(fromIndex, toIndex);
	}
	}
	private final OurVector<Line> lines = new OurVector<>(); // buffer

	// How is this different from lines.length?
	private int nlines; // number of lines in buffer

	private int visible_cols; // number of columns visible in view
	private int extra_cols; // columns needed to support lines longer
	// than visible_cols. Only grows.

	/**
	* @return nlines
	*/
	int nlines() {
	return nlines;
	}

	public int visibleCols() {
	return visible_cols;
	}

	public int totalCols() {
	return visible_cols + extra_cols;
	}

	public Buffer(int visible_cols) {
	this.visible_cols = visible_cols;
	}

	public void setVisibleCols(int visible_cols) {
	int delta = visible_cols - this.visible_cols;
	this.visible_cols = visible_cols;
	extra_cols -= delta;
	if (extra_cols < 0) {
	extra_cols = 0;
	}
	}

	/*
	* Keep track of the largest column # to help set the extent of
	* the horizontal scrollbar.
	*/
	public void noteColumn(int col) {
	int new_extra = col - visible_cols;
	if (new_extra > extra_cols) {
	extra_cols = new_extra;
	// LATER hrange_listener.adjustHRange(extra_cols);
	}
	}

	/* DEBUG
	public static volatile boolean lock = false;

	private void ck_lock() {
	if (lock) {
	System.out.println("Buffer ck_lock fail"); // NOI18N
	printStats();
	Thread.dumpStack();
	}
	}
	*/
	Line lineAt(int brow) {
	try {
	return lines.elementAt(brow);
	} catch (ArrayIndexOutOfBoundsException x) {
	//XXX swallowing this exception caused issue 40129.
	//I've put in a null-check on the return value in sel.paint()
	//as a hotfix. Should find out why bad values are being passed
	//here. Ivan?

	/* DEBUG
	System.out.println("Buffer.lineAt(" +brow+ ") -> null\n");// NOI18N
	Thread.dumpStack();
	*/
	return null;
	}
	}

	Line bottom() {
	return lineAt(nlines);
	}

	public Line appendLine() {
	// DEBUG ck_lock();
	Line l = new Line();
	lines.add(l);
	nlines++;
	return l;
	}

	public Line addLineAt(int row) {
	// DEBUG ck_lock();
	Line l = new Line();
	lines.add(row, l);
	nlines++;
	return l;
	}

	/**
	* Remove 'n' lines starting at 'row'.
	* Return the number of characters deleted as a result.
	*/
	public int removeLinesAt(int row, int n) {
	// DEBUG ck_lock();
	int nchars = 0;
	for (int r = row; r < row + n; r++) {
	nchars += lineAt(r).length() + 1;
	}

	lines.removeRange(row, row + n);
	nlines -= n;

	return nchars;
	}

	public void removeLineAt(int row) {
	// DEBUG ck_lock();
	lines.remove(row);
	nlines--;
	}

	public Line moveLineFromTo(int from, int to) {
	// DEBUG ck_lock();
	Line l = lines.remove(from);
	lines.add(to, l);
	return l;
	}

	/**
	* Visit the physical lines from 'begin', through 'end'.
	* <p>
	* If 'newlines' is set, the passed 'ecol' is set to the actual
	* number of columns in the view to signify that the newline is included.
	* This way of doing it helps with rendering of a whole-line selection.
	* Also Line knows about this and will tack on a "\n" when Line.text()
	* is asked for.
	*/
	void visitLines(BCoord begin, BCoord end, boolean newlines,
	LineVisitor visitor) {

	// In the general case a range is made up of three
	// rectangles. The partial line at top, the partial line
	// at the bottom and the middle range of fully selected lines.

	Line l;
	if (begin.row == end.row) {
	// range is on one line
	l = lineAt(begin.row);
	visitor.visit(l, begin.row, begin.col, end.col);

	} else {
	boolean cont;

	// range spans multiple lines
	l = lineAt(begin.row);
	if (newlines && !l.isWrapped()) {
	cont = visitor.visit(l, begin.row, begin.col, totalCols());
	} else {
	cont = visitor.visit(l, begin.row, begin.col, l.length() - 1);
	}
	if (!cont) {
	return;
	}

	for (int r = begin.row + 1; r < end.row; r++) {
	l = lineAt(r);
	if (newlines && !l.isWrapped()) {
	cont = visitor.visit(l, r, 0, totalCols());
	} else {
	cont = visitor.visit(l, r, 0, l.length() - 1);
	}
	if (!cont) {
	return;
	}
	}

	l = lineAt(end.row);
	cont = visitor.visit(l, end.row, 0, end.col);
	if (!cont) {
	return;
	}
	}
	}

	/*
	* Like visitLines() except in reverse.
	* <p>
	* Starts at 'end' and goes to 'begin'.
	*/
	void reverseVisitLines(BCoord begin, BCoord end, boolean newlines,
	LineVisitor visitor) {

	// very similar to visitLines

	Line l;
	if (begin.row == end.row) {
	// range is on one line
	l = lineAt(begin.row);
	visitor.visit(l, begin.row, begin.col, end.col);

	} else {
	boolean cont;

	// range spans multiple lines
	l = lineAt(end.row);
	cont = visitor.visit(l, end.row, 0, end.col);
	if (!cont) {
	return;
	}

	for (int r = end.row - 1; r > begin.row; r--) {
	l = lineAt(r);
	if (newlines && !l.isWrapped()) {
	cont = visitor.visit(l, r, 0, totalCols());
	} else {
	cont = visitor.visit(l, r, 0, l.length() - 1);
	}
	if (!cont) {
	return;
	}
	}

	l = lineAt(begin.row);
	if (newlines && !l.isWrapped()) {
	cont = visitor.visit(l, begin.row, begin.col, totalCols());
	} else {
	cont = visitor.visit(l, begin.row, begin.col, l.length() - 1);
	}
	if (!cont) {
	return;
	}
	}
	}

	public BExtent find_line(BCoord coord) {
	WordDelineator newLine = WordDelineator.createNewlineDelineator();
	return find_word(newLine, coord);
	}

	public BExtent find_word(WordDelineator word_delineator, BCoord coord) {
	/*
	* Find the boundaries of a "word" at 'coord'.
	*/

	int row = coord.row;
	Line startLine = lineAt(row);

	if (coord.col >= startLine.length()) {
	return new BExtent(coord, coord);
	}

	int lx = 0;
	int rx = 0;
	int beginRow = row;
	int endRow = row;
	StringBuffer lineBuffer;

	// Try to use lineVisitor
	while (beginRow >= 0) {
	Line line = lineAt(beginRow);
	lineBuffer = line.stringBuffer();
	int searchCol = (lx == -1) ? line.length() - 1 : coord.col;
	lx = word_delineator.findLeft(lineBuffer, searchCol, true);

	if (lx != -1) {
	break;
	} else {
	if (beginRow == 0) {
	lx = 0;
	} else if (!lineAt(beginRow - 1).isWrapped()) {
	lx = 0;
	break;
	}
	}
	beginRow--;
	}
	while (endRow < nlines) {
	Line line = lineAt(endRow);
	lineBuffer = line.stringBuffer();
	int searchCol = (rx == -1) ? 0 : coord.col;
	rx = word_delineator.findRight(lineBuffer, searchCol, true);

	if (rx != -1) {
	break;
	} else {
	if (endRow == nlines - 1) {
	rx = line.length() - 1;
	}
	if (!line.isWrapped()) {
	rx = line.length() - 1;
	break;
	}
	}
	endRow++;
	}

	return new BExtent(new BCoord(beginRow, lx),
	new BCoord(endRow, rx));
	}

	/**
	* Back up the coordinate by one character and return new BCoord
	* <p>
	* Travels back over line boundaries
	* <br>
	* Returns null if 'c' is the first character of the buffer.
	*/
	public BCoord backup(BCoord c) {
	if (c.col > 0) {
	return new BCoord(c.row, c.col - 1); // back one in line
	}
	// Cursor is at beginning of line.
	// Need to find the end of previous line, but it might empty,
	// so we go one line back etc
	for (int prevrow = c.row - 1; prevrow >= 0; prevrow--) {
	Line l = lineAt(prevrow);
	if (l.length() != 0) {
	return new BCoord(prevrow, l.length() - 1);
	}
	}

	// prevrow == -1, at beginning of file; nowhere to back to
	return null;
	}

	/*
	* Advance the coordinate by one character and return a new coord.
	* <p>
	* Wraps around line boundaries.
	* <br>
	* Returns null if 'c' is at the last character of the buffer.
	*/
	@SuppressWarnings("ValueOfIncrementOrDecrementUsed")
	public BCoord advance(BCoord c) {
	int row = c.row;
	int col = c.col;

	col++;
	Line l = lineAt(row);
	if (col < l.length()) {
	return new BCoord(row, col);
	}

	// Need to wrap, but the next line might be empty ... so we
	// keep going til either we find a non-empty line or the end
	// of the buffer.
	while (++row < nlines) {
	l = lineAt(row);
	if (l.length() != 0) {
	return new BCoord(row, 0);
	}
	}
	return null;
	}

	private int utilization(int nchars, int ncapacity) {
	float u = ((float) nchars) / ((float) ncapacity);
	float p = u * 100.0f; // convert to percentage
	return (int) p;
	}
	/*
	* Print interesting statistics and facts about this Term
	*/

	public void printStats(boolean indented) {
	int chars = 0;
	int charcapacity = 0;

	int nalines = 0; // lines with attributes
	int attrs = 0;
	int attrcapacity = 0;

	for (int lx = 0; lx < nlines; lx++) {
	Line l = lineAt(lx);
	chars += l.length();
	charcapacity += l.capacity();
	if (l.hasAttributes()) {
	nalines++;
	attrs += l.length();
	attrcapacity += l.capacity();
	}
	}

	Term.indent(indented);
	System.out.println("Buffer:" + // NOI18N
	" nlines " + nlines); // NOI18N

	Term.indent(indented);
	System.out.println(" " + // NOI18N
	" chars " + chars + // NOI18N
	" charcapacity " + charcapacity + // NOI18N
	" utilzn %" + utilization(chars, charcapacity)); // NOI18N

	Term.indent(indented);
	System.out.println(" " + // NOI18N
	" attrs " + attrs + // NOI18N
	" attrcapacity " + attrcapacity + // NOI18N
	" utilzn %" + utilization(attrs, attrcapacity)); // NOI18N

	// estimate actual byte consumption
	final int unitObjectSz = 8;
	final int unitReferenceSz = 4;

	final int unitBooleanSz = 4;
	final int unitCharSz = 2;
	final int unitIntSz = 4;

	final int unitCharArraySz = 12;
	final int unitIntArraySz = 12;

	long bytes = 0;
	long unitLineSz = unitObjectSz +
	unitBooleanSz + // about_to_wrap
	unitReferenceSz + // attr
	unitIntSz + // backgroundColor
	unitReferenceSz + // buf
	unitIntSz + // capacity
	unitIntSz + // glyphId
	unitIntSz + // length
	unitBooleanSz // wrapped
	;
	bytes += unitLineSz * nlines;

	bytes += unitCharArraySz * nlines;
	bytes += unitCharSz * charcapacity;

	bytes += unitIntArraySz * nalines;
	bytes += unitIntSz * attrcapacity;

	Term.indent(indented);
	System.out.println(" " + // NOI18N
	" bytes " + bytes / 1024 + "K"); // NOI18N

	}
	}