lib.terminalemulator/src/org/netbeans/lib/terminalemulator/Line.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.
  */

 /*
  * "Line.java"
  * Line.java 1.12 01/07/24
  */

 package org.netbeans.lib.terminalemulator;

 final class Line {
     public int glyph_glyph;
     public int glyph_rendition;	// Background color for the whole line
     				// This is independent of per-character
 				// rendition.

     private char buf[];		// actual characters
     private int attr[];		// attributes (allocated on demand)

     // SHOULD use shorts?
     private int capacity;	// == buf.length == attr.length
     private int length;		// how much of buf and attr is filled


     public Line() {
         reset();
     }

     public void reset() {
         length = 0;
         capacity = 32;
         buf = new char[capacity];
         attr = null;
         glyphId = 0;
         backgroundColor = 0;
         wrapped = false;
         about_to_wrap = false;
     }

     public void reset(Term term, int end, int eraseAttr) {
         reset();
         clearToEndFrom(term, 0, end, eraseAttr);
     }

     public int capacity() {
         return capacity;
     }

     /**
      * Number of characters in the line.
      * charArray()[length()] is where the cursor or newline would be.
      *
      */
     public int length() {
         return length;
     }

     public boolean hasAttributes() {
         return attr != null;
     }

     private int glyphId;
     public void setGlyphId(int glyphId) {
         this.glyphId = glyphId;
     }
     public int getGlyphId() {
         return glyphId;
     }

     private int backgroundColor;// Background color for the whole line
     // This is independent of per-character
     // rendition.
     public void setBackgroundColor(int bgColor) {
         backgroundColor = bgColor;
     }
     public int getBackgroundColor() {
         return backgroundColor;
     }

     public void setWrapped(boolean wrapped) {
         this.wrapped = wrapped;
     }
     public boolean isWrapped() {
         return wrapped;
     }
     // SHOULD collapse wrapped with about_to_wrap into a bitfield
     private boolean wrapped;


     public boolean setAboutToWrap(boolean about_to_wrap) {
         boolean old_about_to_wrap = about_to_wrap;
         this.about_to_wrap = about_to_wrap;
         return old_about_to_wrap;
     }
     public boolean isAboutToWrap() {
         return about_to_wrap;
     }
     // Perhaps SHOULD have a state: normal, about-to-wrap, wrapped.
     private boolean about_to_wrap;


     /**
      * Return true if we've already seen attributes for this line
      * or 'a' is the first one, in which case we allocate the 'attr' array.
      */
     private boolean haveAttributes(int a) {
         if (attr == null && a != 0) {
             attr = new int[capacity];
         }
         return attr != null;
     }


     public void accumulateInto(int bcol, int ecol, StringBuffer buf) {
         buf.append(this.buf, bcol, ecol-bcol+1);
     }

     public char charAt(int col) {
         return buf[col];
     }

     private void charAtPut(int col, char c) {
         buf[col] = c;
     }

     @Override
     public String toString() {
         assert false;
         return new String(buf);
     }

     public char[] getChars(char[] array) {
         System.arraycopy(buf, 0, array, 0, length);
         return array;
     }

     public int [] attrArray() {
         return attr;
     }


     public byte width(MyFontMetrics metrics, int at) {
         if (at >= capacity)
             return 1;
         return (byte) metrics.wcwidth(charAt(at));
     }

     /*
      * Convert a cell column to a buffer column.
      */
     public int cellToBuf(MyFontMetrics metrics, int target_col) {
         if (metrics.isMultiCell()) {
             int bc = 0;
             int vc = 0;
             for(;;) {
                 int w = width(metrics, bc);
                 if (vc + w - 1 >= target_col)
                     break;
                 vc += w;
                 bc++;
             }
             return bc;
         } else {
             return target_col;
         }
     }

     /*
      * Convert a buffer column to a cell column.
      */
     public int bufToCell(MyFontMetrics metrics, int target_col) {
         if (metrics.isMultiCell()) {
             int vc = 0;
             for (int bc = 0; bc < target_col; bc++) {
                 vc += width(metrics, bc);
             }
             return vc;
         } else {
             return target_col;
         }
     }


     public StringBuffer stringBuffer() {
         // only used for word finding
         // Grrr, why don't we have: new StringBuffer(buf, 0, length);

         // This gets passed on to WordDelineator which is part of the public API
         @SuppressWarnings("StringBufferMayBeStringBuilder")

         StringBuffer sb = new StringBuffer(length);
         return sb.append(buf, 0, length);
     }

     /*
      * Ensure that we have at least 'min_capacity'.
      */
     private void ensureCapacity(Term term, int min_capacity) {

         term.noteColumn(this, min_capacity);

         if (min_capacity <= capacity)
             return;	// nothing to do

         // doubling
         int new_capacity = (length+1) * 2;
         if (new_capacity < 0)
             new_capacity = Integer.MAX_VALUE;
         else if (min_capacity > new_capacity)
             new_capacity = min_capacity;


         char new_buf[] = new char[new_capacity];
         System.arraycopy(buf, 0, new_buf, 0, length);
         buf = new_buf;

         if (attr != null) {
             int new_attr[] = new int[new_capacity];
             System.arraycopy(attr, 0, new_attr, 0, length);
             attr = new_attr;
         }

         capacity = new_capacity;
     }

     private void fillGap(int col, int eraseAttr) {
         // fill any newly opened gap (between length and col) with SP
         for (int cx = length; cx < col; cx++)
             charAtPut(cx, ' ');
         if (haveAttributes(eraseAttr)) {
             for (int cx = length; cx < col; cx++)
                 attr[col] = eraseAttr;
         }
     }

     /**
      * Insert character and attribute at 'column' and shift everything
      * past 'column' right.
      */
     public void insertCharAt(Term term, char c, int column, int a) {
         int new_length = length + 1;

         if (column >= length) {
             new_length = column+1;
             ensureCapacity(term, new_length);
             fillGap(column, 0);                 // SHOULD be eraseAttr?
         } else {
             ensureCapacity(term, new_length);
             System.arraycopy(buf, column, buf, column + 1, length - column);
             if (haveAttributes(a))
                 System.arraycopy(attr, column, attr, column + 1, length - column);
         }

         term.checkForMultiCell(c);

         charAtPut(column, c);
         if (haveAttributes(a))
             attr[column] = a;

         length = new_length;
     }

     /*
      * Generic addition and modification.
      * Line will grow to accomodate column.
      */
     public void setCharAt(Term term, char c, int column, int a, int eraseAttr) {
         if (column >= length) {
             ensureCapacity(term, column+1);
             fillGap(column, eraseAttr);
             length = column+1;
         }
         term.checkForMultiCell(c);
         if (column < 0) {
             throw new IllegalArgumentException(String.format("column=%d; buf_length=%d; buf_capacity=%d", column, length, capacity));   //NOI18N
         }
         charAtPut(column, c);
         if (haveAttributes(a)) {
             attr[column] = a;
         }
     }

     public void deleteCharAt(int column) {
         if (column < 0 || column >= length)
             return;
         System.arraycopy(buf, column+1, buf, column, length-column-1);
         charAtPut(length-1, (char) 0);
         if (attr != null) {
             System.arraycopy(attr, column+1, attr, column, length-column-1);
             attr[length-1] = 0;
         }
         // SHOULD move this up
         length--;
     }

     public void clearToEndFrom(Term term, int from, int end, int eraseAttr) {
         ensureCapacity(term, end+1);
         fillGap(end, eraseAttr);

         // Grrr, why is there a System.arrayCopy() but no System.arrayClear()?
         for (int cx = from; cx <= end; cx++)
             charAtPut(cx, ' ');
         if (haveAttributes(eraseAttr)) {
             for (int cx = from; cx <= end; cx++)
                 attr[cx] = eraseAttr;
         }
         length = end+1;
     }

     public void clearTo(Term term, int col, int eraseAttr) {
         ensureCapacity(term, col+1);
         fillGap(col, eraseAttr);

         for (int cx = 0; cx <= col; cx++)
             charAtPut(cx, ' ');
         if (haveAttributes(eraseAttr)) {
             for (int cx = 0; cx <= col; cx++)
                 attr[cx] = eraseAttr;
         }
         if (length < col+1)
             length = col+1;
     }

     public void clearFromTo(Term term, int from, int to, int eraseAttr) {
         if (from > to)
             return;
         ensureCapacity(term, to+1);
         fillGap(to, eraseAttr);

         for (int cx = from; cx <= to; cx++)
             charAtPut(cx, ' ');
         if (haveAttributes(eraseAttr)) {
             for (int cx = from; cx <= to; cx++)
                 attr[cx] = eraseAttr;
         }
         if (length < to+1)
             length = to+1;
     }

     /*
      * Used for selections
      * If the ecol is past the actual line length a "\n" is appended.
      */
     @SuppressWarnings("AssignmentToMethodParameter")
     public String text(int bcol, int ecol) {
         /* DEBUG
         System.out.println("Line.text(bcol " + bcol + " ecol " + ecol + ")");	// NOI18N
         System.out.println("\tlength " + length);	// NOI18N
          */


         String newline = "";	// NOI18N

         // This only happens for 'empty' lines below the cursor.
         // Actually it also happens for 'empty' lines in the middle.
         // See issue 31951 for example.
         // So in order to get newlines in selected text we will also get
         // newlines from the 'empty' lines below the cursor.
         // This is in fact what xterm does.
         // DtTerm doesn't allow selection of the 'empty' lines below the
         // cursor, but that is issue 21577 and is not easy to solve.

         if (length == 0)
 	    return "\n"; // NOI18N

         if (ecol >= length) {
             // The -1 snuffs out the newline.
             ecol = length-1;
             newline = "\n";	// NOI18N

             if (bcol >= length)
                 bcol = length-1;
         }
         int count = ecol - bcol + 1;
         if (bcol < 0 ||  count < 0) {
             throw new IllegalArgumentException(String.format("offset=%d; count=%d; buf_length=%d; buf_capacity=%d", bcol, count, length, capacity));    //NOI18N
         }
         return new String(buf, bcol, count) + newline;
     }

     public void setCharacterAttribute(int bcol, int ecol,
             int value, boolean on) {
         // HACK: value is the ANSI code, haveAttributes takes out own
         // compact encoding, but it only checks for 0 so it's OK.
         if (!haveAttributes(value))
             return;

 	try {
 	    if (on) {
 		for (int c = bcol; c <= ecol; c++)
 		    attr[c] = Attr.setAttribute(attr[c], value);
 	    } else {
 		for (int c = bcol; c <= ecol; c++)
 		    attr[c] = Attr.unsetAttribute(attr[c], value);
 	    }
 	} catch (ArrayIndexOutOfBoundsException x) {
 	    System.out.printf("bcol %d  ecol %d  capacity %d  length %d buf %d  attr %d", // NOI18N
 		    bcol, ecol, capacity, length, buf.length, attr.length);
 	    throw x;
 	}
     }
 }
	/**
	* 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.
	*/

	/*
	* "Line.java"
	* Line.java 1.12 01/07/24
	*/

	package org.netbeans.lib.terminalemulator;

	final class Line {
	public int glyph_glyph;
	public int glyph_rendition; // Background color for the whole line
	// This is independent of per-character
	// rendition.

	private char buf[]; // actual characters
	private int attr[]; // attributes (allocated on demand)

	// SHOULD use shorts?
	private int capacity; // == buf.length == attr.length
	private int length; // how much of buf and attr is filled


	public Line() {
	reset();
	}

	public void reset() {
	length = 0;
	capacity = 32;
	buf = new char[capacity];
	attr = null;
	glyphId = 0;
	backgroundColor = 0;
	wrapped = false;
	about_to_wrap = false;
	}

	public void reset(Term term, int end, int eraseAttr) {
	reset();
	clearToEndFrom(term, 0, end, eraseAttr);
	}

	public int capacity() {
	return capacity;
	}

	/**
	* Number of characters in the line.
	* charArray()[length()] is where the cursor or newline would be.
	*
	*/
	public int length() {
	return length;
	}

	public boolean hasAttributes() {
	return attr != null;
	}

	private int glyphId;
	public void setGlyphId(int glyphId) {
	this.glyphId = glyphId;
	}
	public int getGlyphId() {
	return glyphId;
	}

	private int backgroundColor;// Background color for the whole line
	// This is independent of per-character
	// rendition.
	public void setBackgroundColor(int bgColor) {
	backgroundColor = bgColor;
	}
	public int getBackgroundColor() {
	return backgroundColor;
	}

	public void setWrapped(boolean wrapped) {
	this.wrapped = wrapped;
	}
	public boolean isWrapped() {
	return wrapped;
	}
	// SHOULD collapse wrapped with about_to_wrap into a bitfield
	private boolean wrapped;



	public boolean setAboutToWrap(boolean about_to_wrap) {
	boolean old_about_to_wrap = about_to_wrap;
	this.about_to_wrap = about_to_wrap;
	return old_about_to_wrap;
	}
	public boolean isAboutToWrap() {
	return about_to_wrap;
	}
	// Perhaps SHOULD have a state: normal, about-to-wrap, wrapped.
	private boolean about_to_wrap;


	/**
	* Return true if we've already seen attributes for this line
	* or 'a' is the first one, in which case we allocate the 'attr' array.
	*/
	private boolean haveAttributes(int a) {
	if (attr == null && a != 0) {
	attr = new int[capacity];
	}
	return attr != null;
	}


	public void accumulateInto(int bcol, int ecol, StringBuffer buf) {
	buf.append(this.buf, bcol, ecol-bcol+1);
	}

	public char charAt(int col) {
	return buf[col];
	}

	private void charAtPut(int col, char c) {
	buf[col] = c;
	}

	@Override
	public String toString() {
	assert false;
	return new String(buf);
	}

	public char[] getChars(char[] array) {
	System.arraycopy(buf, 0, array, 0, length);
	return array;
	}

	public int [] attrArray() {
	return attr;
	}


	public byte width(MyFontMetrics metrics, int at) {
	if (at >= capacity)
	return 1;
	return (byte) metrics.wcwidth(charAt(at));
	}

	/*
	* Convert a cell column to a buffer column.
	*/
	public int cellToBuf(MyFontMetrics metrics, int target_col) {
	if (metrics.isMultiCell()) {
	int bc = 0;
	int vc = 0;
	for(;;) {
	int w = width(metrics, bc);
	if (vc + w - 1 >= target_col)
	break;
	vc += w;
	bc++;
	}
	return bc;
	} else {
	return target_col;
	}
	}

	/*
	* Convert a buffer column to a cell column.
	*/
	public int bufToCell(MyFontMetrics metrics, int target_col) {
	if (metrics.isMultiCell()) {
	int vc = 0;
	for (int bc = 0; bc < target_col; bc++) {
	vc += width(metrics, bc);
	}
	return vc;
	} else {
	return target_col;
	}
	}



	public StringBuffer stringBuffer() {
	// only used for word finding
	// Grrr, why don't we have: new StringBuffer(buf, 0, length);

	// This gets passed on to WordDelineator which is part of the public API
	@SuppressWarnings("StringBufferMayBeStringBuilder")

	StringBuffer sb = new StringBuffer(length);
	return sb.append(buf, 0, length);
	}

	/*
	* Ensure that we have at least 'min_capacity'.
	*/
	private void ensureCapacity(Term term, int min_capacity) {

	term.noteColumn(this, min_capacity);

	if (min_capacity <= capacity)
	return; // nothing to do

	// doubling
	int new_capacity = (length+1) * 2;
	if (new_capacity < 0)
	new_capacity = Integer.MAX_VALUE;
	else if (min_capacity > new_capacity)
	new_capacity = min_capacity;


	char new_buf[] = new char[new_capacity];
	System.arraycopy(buf, 0, new_buf, 0, length);
	buf = new_buf;

	if (attr != null) {
	int new_attr[] = new int[new_capacity];
	System.arraycopy(attr, 0, new_attr, 0, length);
	attr = new_attr;
	}

	capacity = new_capacity;
	}

	private void fillGap(int col, int eraseAttr) {
	// fill any newly opened gap (between length and col) with SP
	for (int cx = length; cx < col; cx++)
	charAtPut(cx, ' ');
	if (haveAttributes(eraseAttr)) {
	for (int cx = length; cx < col; cx++)
	attr[col] = eraseAttr;
	}
	}

	/**
	* Insert character and attribute at 'column' and shift everything
	* past 'column' right.
	*/
	public void insertCharAt(Term term, char c, int column, int a) {
	int new_length = length + 1;

	if (column >= length) {
	new_length = column+1;
	ensureCapacity(term, new_length);
	fillGap(column, 0); // SHOULD be eraseAttr?
	} else {
	ensureCapacity(term, new_length);
	System.arraycopy(buf, column, buf, column + 1, length - column);
	if (haveAttributes(a))
	System.arraycopy(attr, column, attr, column + 1, length - column);
	}

	term.checkForMultiCell(c);

	charAtPut(column, c);
	if (haveAttributes(a))
	attr[column] = a;

	length = new_length;
	}

	/*
	* Generic addition and modification.
	* Line will grow to accomodate column.
	*/
	public void setCharAt(Term term, char c, int column, int a, int eraseAttr) {
	if (column >= length) {
	ensureCapacity(term, column+1);
	fillGap(column, eraseAttr);
	length = column+1;
	}
	term.checkForMultiCell(c);
	if (column < 0) {
	throw new IllegalArgumentException(String.format("column=%d; buf_length=%d; buf_capacity=%d", column, length, capacity)); //NOI18N
	}
	charAtPut(column, c);
	if (haveAttributes(a)) {
	attr[column] = a;
	}
	}

	public void deleteCharAt(int column) {
	if (column < 0 \|\| column >= length)
	return;
	System.arraycopy(buf, column+1, buf, column, length-column-1);
	charAtPut(length-1, (char) 0);
	if (attr != null) {
	System.arraycopy(attr, column+1, attr, column, length-column-1);
	attr[length-1] = 0;
	}
	// SHOULD move this up
	length--;
	}

	public void clearToEndFrom(Term term, int from, int end, int eraseAttr) {
	ensureCapacity(term, end+1);
	fillGap(end, eraseAttr);

	// Grrr, why is there a System.arrayCopy() but no System.arrayClear()?
	for (int cx = from; cx <= end; cx++)
	charAtPut(cx, ' ');
	if (haveAttributes(eraseAttr)) {
	for (int cx = from; cx <= end; cx++)
	attr[cx] = eraseAttr;
	}
	length = end+1;
	}

	public void clearTo(Term term, int col, int eraseAttr) {
	ensureCapacity(term, col+1);
	fillGap(col, eraseAttr);

	for (int cx = 0; cx <= col; cx++)
	charAtPut(cx, ' ');
	if (haveAttributes(eraseAttr)) {
	for (int cx = 0; cx <= col; cx++)
	attr[cx] = eraseAttr;
	}
	if (length < col+1)
	length = col+1;
	}

	public void clearFromTo(Term term, int from, int to, int eraseAttr) {
	if (from > to)
	return;
	ensureCapacity(term, to+1);
	fillGap(to, eraseAttr);

	for (int cx = from; cx <= to; cx++)
	charAtPut(cx, ' ');
	if (haveAttributes(eraseAttr)) {
	for (int cx = from; cx <= to; cx++)
	attr[cx] = eraseAttr;
	}
	if (length < to+1)
	length = to+1;
	}

	/*
	* Used for selections
	* If the ecol is past the actual line length a "\n" is appended.
	*/
	@SuppressWarnings("AssignmentToMethodParameter")
	public String text(int bcol, int ecol) {
	/* DEBUG
	System.out.println("Line.text(bcol " + bcol + " ecol " + ecol + ")"); // NOI18N
	System.out.println("\tlength " + length); // NOI18N
	*/


	String newline = ""; // NOI18N

	// This only happens for 'empty' lines below the cursor.
	// Actually it also happens for 'empty' lines in the middle.
	// See issue 31951 for example.
	// So in order to get newlines in selected text we will also get
	// newlines from the 'empty' lines below the cursor.
	// This is in fact what xterm does.
	// DtTerm doesn't allow selection of the 'empty' lines below the
	// cursor, but that is issue 21577 and is not easy to solve.

	if (length == 0)
	return "\n"; // NOI18N

	if (ecol >= length) {
	// The -1 snuffs out the newline.
	ecol = length-1;
	newline = "\n"; // NOI18N

	if (bcol >= length)
	bcol = length-1;
	}
	int count = ecol - bcol + 1;
	if (bcol < 0 \|\| count < 0) {
	throw new IllegalArgumentException(String.format("offset=%d; count=%d; buf_length=%d; buf_capacity=%d", bcol, count, length, capacity)); //NOI18N
	}
	return new String(buf, bcol, count) + newline;
	}

	public void setCharacterAttribute(int bcol, int ecol,
	int value, boolean on) {
	// HACK: value is the ANSI code, haveAttributes takes out own
	// compact encoding, but it only checks for 0 so it's OK.
	if (!haveAttributes(value))
	return;

	try {
	if (on) {
	for (int c = bcol; c <= ecol; c++)
	attr[c] = Attr.setAttribute(attr[c], value);
	} else {
	for (int c = bcol; c <= ecol; c++)
	attr[c] = Attr.unsetAttribute(attr[c], value);
	}
	} catch (ArrayIndexOutOfBoundsException x) {
	System.out.printf("bcol %d ecol %d capacity %d length %d buf %d attr %d", // NOI18N
	bcol, ecol, capacity, length, buf.length, attr.length);
	throw x;
	}
	}
	}