blur-shell/src/main/java/org/apache/blur/shell/TableDisplay.java - incubator-retired-blur - 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.
  */
 package org.apache.blur.shell;

 import java.io.Closeable;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.Writer;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.atomic.AtomicBoolean;

 import jline.Terminal;
 import jline.console.ConsoleReader;

 public class TableDisplay implements Closeable {

   public static void main(String[] args) throws IOException, InterruptedException {

     // System.out.println("\u001B[1mfoo\u001B[0m@bar\u001B[32m@baz\u001B[0m>");

     // \u001B[0m normal
     // \u001B[33m yellow

     // System.out.println("\u001B[33mCOLUMN\u001B[0mnormal");
     //
     // for (int i = 0; i < 100; i++) {
     // System.out.println("\u001B[0m" + i + "\u001B[" + i + "mfoo");
     // }

     ConsoleReader reader = new ConsoleReader();
     TableDisplay tableDisplay = new TableDisplay(reader);
     tableDisplay.setSeperator("|");
     // Random random = new Random();
     int maxX = 20;
     int maxY = 100;
     tableDisplay.setHeader(0, "");
     for (int i = 1; i < maxX; i++) {
       tableDisplay.setHeader(i, "col-" + i);
     }

     for (int i = 0; i < maxY; i++) {
       tableDisplay.set(0, i, i);
     }

     final AtomicBoolean running = new AtomicBoolean(true);

     tableDisplay.addKeyHook(new Runnable() {
       @Override
       public void run() {
         synchronized (running) {
           running.set(false);
           running.notifyAll();
         }
       }
     }, 'q');

     try {
       // int i = 0;
       // while (true) {
       // if (i >= 100000) {
       // i = 0;
       // }
       // tableDisplay.set(random.nextInt(maxX) + 1, random.nextInt(maxY),
       // random.nextLong());
       // Thread.sleep(3000);
       // i++;
       // }
       for (int x = 0; x < maxX; x++) {
         for (int y = 0; y < maxY; y++) {
           if (x == 7 && y == 7) {
             tableDisplay.set(x, y, highlight(x + "," + y));
           } else {
             tableDisplay.set(x, y, x + "," + y);
           }
         }
       }
       while (running.get()) {
         synchronized (running) {
           running.wait(1000);
         }
       }
     } finally {
       tableDisplay.close();
     }
   }

   private static String highlight(String s) {
     // return s;
     return "\u001B[33m" + s + "\u001B[0m";
   }

   public void addKeyHook(Runnable runnable, int c) {
     _keyHookMap.put(c, runnable);
   }

   private static final String SEP = "|";
   private final ConsoleReader _reader;
   private final ConcurrentMap<Key, Object> _values = new ConcurrentHashMap<TableDisplay.Key, Object>();
   private final ConcurrentMap<Integer, String> _header = new ConcurrentHashMap<Integer, String>();
   private final ConcurrentMap<Integer, Integer> _maxWidth = new ConcurrentHashMap<Integer, Integer>();
   private final AtomicBoolean _running = new AtomicBoolean(true);
   private final Thread _paintThread;
   private final Canvas _canvas;
   private int _maxY;
   private int _maxX;
   private String _seperator = SEP;
   private final Thread _inputReaderThread;
   private final Map<Integer, Runnable> _keyHookMap = new ConcurrentHashMap<Integer, Runnable>();
   private final AtomicBoolean _stopReadingInput = new AtomicBoolean(false);
   private String _description = "";
   private volatile long _lastPaint = 0;
   private volatile boolean _dirty = true;

   public void setDescription(String description) {
     _description = description;
   }

   public void setSeperator(String seperator) {
     _seperator = seperator;
   }

   public TableDisplay(ConsoleReader reader) {
     _reader = reader;
     _canvas = new Canvas(_reader);
     _paintThread = new Thread(new Runnable() {
       @Override
       public void run() {
         while (_running.get()) {
           long now = System.currentTimeMillis();
           synchronized (_canvas) {
             if (_lastPaint + 1000 < now) {
               try {
                 render(_canvas);
               } catch (IOException e) {
                 e.printStackTrace();
               }
               _lastPaint = System.currentTimeMillis();
               _dirty = false;
             }
             if (_dirty) {
               try {
                 _canvas.wait(1000);
               } catch (InterruptedException e) {
                 e.printStackTrace();
               }
             } else {
               try {
                 _canvas.wait();
               } catch (InterruptedException e) {
                 e.printStackTrace();
               }
             }
           }
         }
       }
     });
     _paintThread.setDaemon(true);
     _paintThread.setName("Render Thread");
     _paintThread.start();
     _inputReaderThread = new Thread(new Runnable() {
       @Override
       public void run() {
         try {
           InputStream input = _reader.getInput();
           int read;
           while (!_stopReadingInput.get() && _running.get() && (read = input.read()) != -1) {
             if (read == 27) {
               if (input.read() == 91) {
                 read = input.read();
                 switch (read) {
                 case 68:
                   // left
                   _canvas.moveLeft();
                   break;
                 case 67:
                   // right
                   _canvas.moveRight();
                   break;
                 case 65:
                   // up
                   _canvas.moveUp();
                   break;
                 case 66:
                   // down
                   _canvas.moveDown();
                   break;
                 case 53:
                   // up
                   _canvas.pageUp();
                   break;
                 case 54:
                   // down
                   _canvas.pageDown();
                   break;
                 default:
                   break;
                 }
                 _lastPaint = 0;
               }
             } else {
               Runnable runnable = _keyHookMap.get(read);
               if (runnable != null) {
                 runnable.run();
               }
             }
             paint();
           }
         } catch (IOException e) {
           e.printStackTrace();
         }
       }
     });
     _inputReaderThread.setName("Input Reader Thread");
     _inputReaderThread.setDaemon(true);
     _inputReaderThread.start();
   }

   private void render(Canvas canvas) throws IOException {
     canvas.reset();
     canvas.resetHeader();
     canvas.appendHeader(_description);
     canvas.endHeader();
     buildHeaderOutput(canvas);
     buildTableOutput(canvas);
     canvas.write();
   }

   private void buildHeaderOutput(Canvas canvas) {
     canvas.startHeader();
     for (int x = 0; x < _maxX; x++) {
       if (x != 0) {
         canvas.appendHeader(_seperator);
       }
       Object value = _header.get(x);
       int widthForColumn = getWidthForColumn(x);
       bufferHeader(canvas, getString(value), widthForColumn);
     }
     canvas.endHeader();
   }

   private void buildTableOutput(Canvas canvas) {
     for (int y = 0; y < _maxY; y++) {
       canvas.startLine();
       for (int x = 0; x < _maxX; x++) {
         if (x != 0) {
           canvas.append(_seperator);
         }
         Key key = new Key(x, y);
         Object value = _values.get(key);
         int widthForColumn = getWidthForColumn(x);
         buffer(canvas, getString(value), widthForColumn);
       }
       canvas.endLine();
     }
   }

   private int getWidthForColumn(int x) {
     Integer width = _maxWidth.get(x);
     if (width == null) {
       return 0;
     }
     return width;
   }

   private void bufferHeader(Canvas canvas, String value, int width) {
     canvas.appendHeader(value);
     width -= getVisibleLength(value);
     while (width > 0) {
       canvas.appendHeader(' ');
       width--;
     }
   }

   private void buffer(Canvas canvas, String value, int width) {
     canvas.append(value);
     width -= getVisibleLength(value);
     while (width > 0) {
       canvas.append(' ');
       width--;
     }
   }

   public void setHeader(int x, String name) {
     _header.put(x, name);
     setMaxWidth(x, name);
     paint();
   }

   public void set(int x, int y, Object value) {
     if (value == null) {
       remove(x, y);
       return;
     }
     _values.put(new Key(x, y), value);
     setMaxX(x);
     setMaxY(y);
     setMaxWidth(x, value);
     paint();
   }

   private void paint() {
     synchronized (_canvas) {
       _canvas.notify();
       _dirty = true;
     }
   }

   private void setMaxWidth(int x, Object value) {
     if (value != null) {
       String s = getString(value);
       int length = getVisibleLength(s);
       while (true) {
         Integer width = _maxWidth.get(x);
         if (width == null) {
           width = _maxWidth.putIfAbsent(x, length);
           if (width == null) {
             return;
           }
         }
         if (width < length) {
           if (_maxWidth.replace(x, width, length)) {
             return;
           }
         } else {
           return;
         }
       }
     }
   }

   private int getVisibleLength(String s) {
     int length = 0;
     boolean color = false;
     for (int i = 0; i < s.length(); i++) {
       char c = s.charAt(i);
       if (color) {
         if (c == 'm') {
           color = false;
         }
       } else {
         if (c == 27) {
           color = true;
         } else {
           length++;
         }
       }
     }
     return length;
   }

   private String getString(Object value) {
     if (value != null) {
       return value.toString();
     }
     return "";
   }

   private void setMaxY(int y) {
     if (_maxY < y + 1) {
       _maxY = y + 1;
     }
   }

   private void setMaxX(int x) {
     if (_maxX < x + 1) {
       _maxX = x + 1;
     }
   }

   public void remove(int x, int y) {
     _values.remove(new Key(x, y));
   }

   @Override
   public void close() throws IOException {
     if (_running.get()) {
       _running.set(false);
       _inputReaderThread.interrupt();
       try {
         _inputReaderThread.join();
       } catch (InterruptedException e) {
         throw new IOException(e);
       }
     }
   }

   public static class Key implements Comparable<Key> {

     final int _x;
     final int _y;

     public Key(int x, int y) {
       _x = x;
       _y = y;
     }

     public int getX() {
       return _x;
     }

     public int getY() {
       return _y;
     }

     @Override
     public int compareTo(Key o) {
       if (_y == o._y) {
         return _x - o._x;
       }
       return _y - o._y;
     }

     @Override
     public int hashCode() {
       final int prime = 31;
       int result = 1;
       result = prime * result + _x;
       result = prime * result + _y;
       return result;
     }

     @Override
     public boolean equals(Object obj) {
       if (this == obj)
         return true;
       if (obj == null)
         return false;
       if (getClass() != obj.getClass())
         return false;
       Key other = (Key) obj;
       if (_x != other._x)
         return false;
       if (_y != other._y)
         return false;
       return true;
     }
   }

   public static class LineBuilder {

     static class LineBuilderPart {
       String _visible;
       String _notVisible;
     }

     private List<LineBuilderPart> _parts = new ArrayList<LineBuilderPart>();
     private boolean _readingColor;
     private StringBuilder _currentNotVisible = new StringBuilder();
     private StringBuilder _currentVisible = new StringBuilder();

     public void reset() {
       _currentNotVisible.setLength(0);
       _currentVisible.setLength(0);
       _parts.clear();
     }

     public void close() {
       startNewPart();
     }

     public int visibleLength() {
       int l = 0;
       for (LineBuilderPart p : _parts) {
         l += p._visible.length();
       }
       return l;
     }

     public String substring(int start, int end) {
       StringBuilder b = new StringBuilder();
       Iterator<LineBuilderPart> iterator = _parts.iterator();
       LineBuilderPart current = iterator.next();
       int partPos = 0;
       boolean currentPartHasEmittedNonVisible = false;
       for (int i = 0; i < end; i++) {
         if (partPos >= current._visible.length()) {
           current = iterator.next();
           partPos = 0;
           currentPartHasEmittedNonVisible = false;
         }
         if (isVisible(i, start, end)) {
           if (!currentPartHasEmittedNonVisible) {
             b.append(current._notVisible);
             currentPartHasEmittedNonVisible = true;
           }
           b.append(current._visible.charAt(partPos));
         }
         partPos++;
       }
       return b.toString();
     }

     private boolean isVisible(int i, int start, int end) {
       if (i >= start && i < end) {
         return true;
       }
       return false;
     }

     public void append(char c) {
       if (_readingColor) {
         if (c == 'm') {
           _readingColor = false;
           _currentNotVisible.append(c);
         } else {
           _currentNotVisible.append(c);
         }
       } else {
         if (c == 27) {
           startNewPart();
           _readingColor = true;
           _currentNotVisible.append(c);
         } else {
           _currentVisible.append(c);
         }
       }
     }

     private void startNewPart() {
       LineBuilderPart part = new LineBuilderPart();
       part._notVisible = _currentNotVisible.toString();
       part._visible = _currentVisible.toString();
       _parts.add(part);
       _currentNotVisible.setLength(0);
       _currentVisible.setLength(0);
     }

     public void append(String s) {
       for (int i = 0; i < s.length(); i++) {
         append(s.charAt(i));
       }
     }

   }

   static class Canvas {

     private final StringBuilder _screenBuilder = new StringBuilder();
     private final LineBuilder _lineBuilder = new LineBuilder();
     private final StringBuilder _headerScreenBuilder = new StringBuilder();
     private final LineBuilder _headerLineBuilder = new LineBuilder();
     private final ConsoleReader _reader;
     private int _height;
     private int _width;
     private int _line;
     private volatile int _posX = 0;
     private volatile int _posY = 0;
     private int _leftRightMoveSize;
     private int _headerLine;

     public Canvas(ConsoleReader reader) {
       _reader = reader;
     }

     public void resetHeader() {
       _headerLine = 0;
       _headerScreenBuilder.setLength(0);
     }

     public void reset() {
       _line = 0;
       _screenBuilder.setLength(0);
       Terminal terminal = _reader.getTerminal();
       _height = terminal.getHeight() - 3;
       _width = terminal.getWidth() - 2;
       _leftRightMoveSize = _width / 4;
     }

     public void endLine() {
       _lineBuilder.close();
       int pos = _line - _posY;
       if (pos >= 0 && pos < (_height - _headerLine)) {
         int end = _posX + _width;
         int s = _posX;
         int e = Math.min(_lineBuilder.visibleLength(), end);
         if (e > s) {
           _screenBuilder.append(_lineBuilder.substring(s, e));
         }
         _screenBuilder.append('\n');
       }
       _line++;
       _lineBuilder.reset();
     }

     public void endHeader() {
       _headerLineBuilder.close();
       int end = _posX + _width;
       int s = _posX;
       int e = Math.min(_headerLineBuilder.visibleLength(), end);
       if (e > s) {
         _headerScreenBuilder.append(_headerLineBuilder.substring(s, e));
       }
       _headerScreenBuilder.append('\n');
       _headerLineBuilder.reset();
       _headerLine++;
     }

     public void startLine() {

     }

     public void startHeader() {

     }

     public void appendHeader(char c) {
       _headerLineBuilder.append(c);
     }

     public void appendHeader(String s) {
       _headerLineBuilder.append(s);
     }

     public void append(char c) {
       _lineBuilder.append(c);
     }

     public void append(String s) {
       _lineBuilder.append(s);
     }

     public void write() throws IOException {
       _reader.clearScreen();
       Writer writer = _reader.getOutput();
       writer.write(_headerScreenBuilder.toString());
       writer.write(_screenBuilder.toString());
       writer.flush();
     }

     public void moveLeft() {
       if (_posX > 0) {
         _posX -= _leftRightMoveSize;
       }
     }

     public void moveRight() {
       _posX += _leftRightMoveSize;
     }

     public void moveUp() {
       if (_posY > 0) {
         _posY--;
       }
     }

     public void moveDown() {
       _posY++;
     }

     public void pageUp() {
       if (_posY < _height) {
         _posY = 0;
       } else {
         _posY -= _height;
       }
     }

     public void pageDown() {
       _posY += _height;
     }

   }

   public void setStopReadingInput(boolean b) {
     _stopReadingInput.set(true);
   }

 }
	/**
	* 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.
	*/
	package org.apache.blur.shell;

	import java.io.Closeable;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.Writer;
	import java.util.ArrayList;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;
	import java.util.concurrent.ConcurrentHashMap;
	import java.util.concurrent.ConcurrentMap;
	import java.util.concurrent.atomic.AtomicBoolean;

	import jline.Terminal;
	import jline.console.ConsoleReader;

	public class TableDisplay implements Closeable {

	public static void main(String[] args) throws IOException, InterruptedException {

	// System.out.println("\u001B[1mfoo\u001B[0m@bar\u001B[32m@baz\u001B[0m>");

	// \u001B[0m normal
	// \u001B[33m yellow

	// System.out.println("\u001B[33mCOLUMN\u001B[0mnormal");
	//
	// for (int i = 0; i < 100; i++) {
	// System.out.println("\u001B[0m" + i + "\u001B[" + i + "mfoo");
	// }

	ConsoleReader reader = new ConsoleReader();
	TableDisplay tableDisplay = new TableDisplay(reader);
	tableDisplay.setSeperator("\|");
	// Random random = new Random();
	int maxX = 20;
	int maxY = 100;
	tableDisplay.setHeader(0, "");
	for (int i = 1; i < maxX; i++) {
	tableDisplay.setHeader(i, "col-" + i);
	}

	for (int i = 0; i < maxY; i++) {
	tableDisplay.set(0, i, i);
	}

	final AtomicBoolean running = new AtomicBoolean(true);

	tableDisplay.addKeyHook(new Runnable() {
	@Override
	public void run() {
	synchronized (running) {
	running.set(false);
	running.notifyAll();
	}
	}
	}, 'q');

	try {
	// int i = 0;
	// while (true) {
	// if (i >= 100000) {
	// i = 0;
	// }
	// tableDisplay.set(random.nextInt(maxX) + 1, random.nextInt(maxY),
	// random.nextLong());
	// Thread.sleep(3000);
	// i++;
	// }
	for (int x = 0; x < maxX; x++) {
	for (int y = 0; y < maxY; y++) {
	if (x == 7 && y == 7) {
	tableDisplay.set(x, y, highlight(x + "," + y));
	} else {
	tableDisplay.set(x, y, x + "," + y);
	}
	}
	}
	while (running.get()) {
	synchronized (running) {
	running.wait(1000);
	}
	}
	} finally {
	tableDisplay.close();
	}
	}

	private static String highlight(String s) {
	// return s;
	return "\u001B[33m" + s + "\u001B[0m";
	}

	public void addKeyHook(Runnable runnable, int c) {
	_keyHookMap.put(c, runnable);
	}

	private static final String SEP = "\|";
	private final ConsoleReader _reader;
	private final ConcurrentMap<Key, Object> _values = new ConcurrentHashMap<TableDisplay.Key, Object>();
	private final ConcurrentMap<Integer, String> _header = new ConcurrentHashMap<Integer, String>();
	private final ConcurrentMap<Integer, Integer> _maxWidth = new ConcurrentHashMap<Integer, Integer>();
	private final AtomicBoolean _running = new AtomicBoolean(true);
	private final Thread _paintThread;
	private final Canvas _canvas;
	private int _maxY;
	private int _maxX;
	private String _seperator = SEP;
	private final Thread _inputReaderThread;
	private final Map<Integer, Runnable> _keyHookMap = new ConcurrentHashMap<Integer, Runnable>();
	private final AtomicBoolean _stopReadingInput = new AtomicBoolean(false);
	private String _description = "";
	private volatile long _lastPaint = 0;
	private volatile boolean _dirty = true;

	public void setDescription(String description) {
	_description = description;
	}

	public void setSeperator(String seperator) {
	_seperator = seperator;
	}

	public TableDisplay(ConsoleReader reader) {
	_reader = reader;
	_canvas = new Canvas(_reader);
	_paintThread = new Thread(new Runnable() {
	@Override
	public void run() {
	while (_running.get()) {
	long now = System.currentTimeMillis();
	synchronized (_canvas) {
	if (_lastPaint + 1000 < now) {
	try {
	render(_canvas);
	} catch (IOException e) {
	e.printStackTrace();
	}
	_lastPaint = System.currentTimeMillis();
	_dirty = false;
	}
	if (_dirty) {
	try {
	_canvas.wait(1000);
	} catch (InterruptedException e) {
	e.printStackTrace();
	}
	} else {
	try {
	_canvas.wait();
	} catch (InterruptedException e) {
	e.printStackTrace();
	}
	}
	}
	}
	}
	});
	_paintThread.setDaemon(true);
	_paintThread.setName("Render Thread");
	_paintThread.start();
	_inputReaderThread = new Thread(new Runnable() {
	@Override
	public void run() {
	try {
	InputStream input = _reader.getInput();
	int read;
	while (!_stopReadingInput.get() && _running.get() && (read = input.read()) != -1) {
	if (read == 27) {
	if (input.read() == 91) {
	read = input.read();
	switch (read) {
	case 68:
	// left
	_canvas.moveLeft();
	break;
	case 67:
	// right
	_canvas.moveRight();
	break;
	case 65:
	// up
	_canvas.moveUp();
	break;
	case 66:
	// down
	_canvas.moveDown();
	break;
	case 53:
	// up
	_canvas.pageUp();
	break;
	case 54:
	// down
	_canvas.pageDown();
	break;
	default:
	break;
	}
	_lastPaint = 0;
	}
	} else {
	Runnable runnable = _keyHookMap.get(read);
	if (runnable != null) {
	runnable.run();
	}
	}
	paint();
	}
	} catch (IOException e) {
	e.printStackTrace();
	}
	}
	});
	_inputReaderThread.setName("Input Reader Thread");
	_inputReaderThread.setDaemon(true);
	_inputReaderThread.start();
	}

	private void render(Canvas canvas) throws IOException {
	canvas.reset();
	canvas.resetHeader();
	canvas.appendHeader(_description);
	canvas.endHeader();
	buildHeaderOutput(canvas);
	buildTableOutput(canvas);
	canvas.write();
	}

	private void buildHeaderOutput(Canvas canvas) {
	canvas.startHeader();
	for (int x = 0; x < _maxX; x++) {
	if (x != 0) {
	canvas.appendHeader(_seperator);
	}
	Object value = _header.get(x);
	int widthForColumn = getWidthForColumn(x);
	bufferHeader(canvas, getString(value), widthForColumn);
	}
	canvas.endHeader();
	}

	private void buildTableOutput(Canvas canvas) {
	for (int y = 0; y < _maxY; y++) {
	canvas.startLine();
	for (int x = 0; x < _maxX; x++) {
	if (x != 0) {
	canvas.append(_seperator);
	}
	Key key = new Key(x, y);
	Object value = _values.get(key);
	int widthForColumn = getWidthForColumn(x);
	buffer(canvas, getString(value), widthForColumn);
	}
	canvas.endLine();
	}
	}

	private int getWidthForColumn(int x) {
	Integer width = _maxWidth.get(x);
	if (width == null) {
	return 0;
	}
	return width;
	}

	private void bufferHeader(Canvas canvas, String value, int width) {
	canvas.appendHeader(value);
	width -= getVisibleLength(value);
	while (width > 0) {
	canvas.appendHeader(' ');
	width--;
	}
	}

	private void buffer(Canvas canvas, String value, int width) {
	canvas.append(value);
	width -= getVisibleLength(value);
	while (width > 0) {
	canvas.append(' ');
	width--;
	}
	}

	public void setHeader(int x, String name) {
	_header.put(x, name);
	setMaxWidth(x, name);
	paint();
	}

	public void set(int x, int y, Object value) {
	if (value == null) {
	remove(x, y);
	return;
	}
	_values.put(new Key(x, y), value);
	setMaxX(x);
	setMaxY(y);
	setMaxWidth(x, value);
	paint();
	}

	private void paint() {
	synchronized (_canvas) {
	_canvas.notify();
	_dirty = true;
	}
	}

	private void setMaxWidth(int x, Object value) {
	if (value != null) {
	String s = getString(value);
	int length = getVisibleLength(s);
	while (true) {
	Integer width = _maxWidth.get(x);
	if (width == null) {
	width = _maxWidth.putIfAbsent(x, length);
	if (width == null) {
	return;
	}
	}
	if (width < length) {
	if (_maxWidth.replace(x, width, length)) {
	return;
	}
	} else {
	return;
	}
	}
	}
	}

	private int getVisibleLength(String s) {
	int length = 0;
	boolean color = false;
	for (int i = 0; i < s.length(); i++) {
	char c = s.charAt(i);
	if (color) {
	if (c == 'm') {
	color = false;
	}
	} else {
	if (c == 27) {
	color = true;
	} else {
	length++;
	}
	}
	}
	return length;
	}

	private String getString(Object value) {
	if (value != null) {
	return value.toString();
	}
	return "";
	}

	private void setMaxY(int y) {
	if (_maxY < y + 1) {
	_maxY = y + 1;
	}
	}

	private void setMaxX(int x) {
	if (_maxX < x + 1) {
	_maxX = x + 1;
	}
	}

	public void remove(int x, int y) {
	_values.remove(new Key(x, y));
	}

	@Override
	public void close() throws IOException {
	if (_running.get()) {
	_running.set(false);
	_inputReaderThread.interrupt();
	try {
	_inputReaderThread.join();
	} catch (InterruptedException e) {
	throw new IOException(e);
	}
	}
	}

	public static class Key implements Comparable<Key> {

	final int _x;
	final int _y;

	public Key(int x, int y) {
	_x = x;
	_y = y;
	}

	public int getX() {
	return _x;
	}

	public int getY() {
	return _y;
	}

	@Override
	public int compareTo(Key o) {
	if (_y == o._y) {
	return _x - o._x;
	}
	return _y - o._y;
	}

	@Override
	public int hashCode() {
	final int prime = 31;
	int result = 1;
	result = prime * result + _x;
	result = prime * result + _y;
	return result;
	}

	@Override
	public boolean equals(Object obj) {
	if (this == obj)
	return true;
	if (obj == null)
	return false;
	if (getClass() != obj.getClass())
	return false;
	Key other = (Key) obj;
	if (_x != other._x)
	return false;
	if (_y != other._y)
	return false;
	return true;
	}
	}

	public static class LineBuilder {

	static class LineBuilderPart {
	String _visible;
	String _notVisible;
	}

	private List<LineBuilderPart> _parts = new ArrayList<LineBuilderPart>();
	private boolean _readingColor;
	private StringBuilder _currentNotVisible = new StringBuilder();
	private StringBuilder _currentVisible = new StringBuilder();

	public void reset() {
	_currentNotVisible.setLength(0);
	_currentVisible.setLength(0);
	_parts.clear();
	}

	public void close() {
	startNewPart();
	}

	public int visibleLength() {
	int l = 0;
	for (LineBuilderPart p : _parts) {
	l += p._visible.length();
	}
	return l;
	}

	public String substring(int start, int end) {
	StringBuilder b = new StringBuilder();
	Iterator<LineBuilderPart> iterator = _parts.iterator();
	LineBuilderPart current = iterator.next();
	int partPos = 0;
	boolean currentPartHasEmittedNonVisible = false;
	for (int i = 0; i < end; i++) {
	if (partPos >= current._visible.length()) {
	current = iterator.next();
	partPos = 0;
	currentPartHasEmittedNonVisible = false;
	}
	if (isVisible(i, start, end)) {
	if (!currentPartHasEmittedNonVisible) {
	b.append(current._notVisible);
	currentPartHasEmittedNonVisible = true;
	}
	b.append(current._visible.charAt(partPos));
	}
	partPos++;
	}
	return b.toString();
	}

	private boolean isVisible(int i, int start, int end) {
	if (i >= start && i < end) {
	return true;
	}
	return false;
	}

	public void append(char c) {
	if (_readingColor) {
	if (c == 'm') {
	_readingColor = false;
	_currentNotVisible.append(c);
	} else {
	_currentNotVisible.append(c);
	}
	} else {
	if (c == 27) {
	startNewPart();
	_readingColor = true;
	_currentNotVisible.append(c);
	} else {
	_currentVisible.append(c);
	}
	}
	}

	private void startNewPart() {
	LineBuilderPart part = new LineBuilderPart();
	part._notVisible = _currentNotVisible.toString();
	part._visible = _currentVisible.toString();
	_parts.add(part);
	_currentNotVisible.setLength(0);
	_currentVisible.setLength(0);
	}

	public void append(String s) {
	for (int i = 0; i < s.length(); i++) {
	append(s.charAt(i));
	}
	}

	}

	static class Canvas {

	private final StringBuilder _screenBuilder = new StringBuilder();
	private final LineBuilder _lineBuilder = new LineBuilder();
	private final StringBuilder _headerScreenBuilder = new StringBuilder();
	private final LineBuilder _headerLineBuilder = new LineBuilder();
	private final ConsoleReader _reader;
	private int _height;
	private int _width;
	private int _line;
	private volatile int _posX = 0;
	private volatile int _posY = 0;
	private int _leftRightMoveSize;
	private int _headerLine;

	public Canvas(ConsoleReader reader) {
	_reader = reader;
	}

	public void resetHeader() {
	_headerLine = 0;
	_headerScreenBuilder.setLength(0);
	}

	public void reset() {
	_line = 0;
	_screenBuilder.setLength(0);
	Terminal terminal = _reader.getTerminal();
	_height = terminal.getHeight() - 3;
	_width = terminal.getWidth() - 2;
	_leftRightMoveSize = _width / 4;
	}

	public void endLine() {
	_lineBuilder.close();
	int pos = _line - _posY;
	if (pos >= 0 && pos < (_height - _headerLine)) {
	int end = _posX + _width;
	int s = _posX;
	int e = Math.min(_lineBuilder.visibleLength(), end);
	if (e > s) {
	_screenBuilder.append(_lineBuilder.substring(s, e));
	}
	_screenBuilder.append('\n');
	}
	_line++;
	_lineBuilder.reset();
	}

	public void endHeader() {
	_headerLineBuilder.close();
	int end = _posX + _width;
	int s = _posX;
	int e = Math.min(_headerLineBuilder.visibleLength(), end);
	if (e > s) {
	_headerScreenBuilder.append(_headerLineBuilder.substring(s, e));
	}
	_headerScreenBuilder.append('\n');
	_headerLineBuilder.reset();
	_headerLine++;
	}

	public void startLine() {

	}

	public void startHeader() {

	}

	public void appendHeader(char c) {
	_headerLineBuilder.append(c);
	}

	public void appendHeader(String s) {
	_headerLineBuilder.append(s);
	}

	public void append(char c) {
	_lineBuilder.append(c);
	}

	public void append(String s) {
	_lineBuilder.append(s);
	}

	public void write() throws IOException {
	_reader.clearScreen();
	Writer writer = _reader.getOutput();
	writer.write(_headerScreenBuilder.toString());
	writer.write(_screenBuilder.toString());
	writer.flush();
	}

	public void moveLeft() {
	if (_posX > 0) {
	_posX -= _leftRightMoveSize;
	}
	}

	public void moveRight() {
	_posX += _leftRightMoveSize;
	}

	public void moveUp() {
	if (_posY > 0) {
	_posY--;
	}
	}

	public void moveDown() {
	_posY++;
	}

	public void pageUp() {
	if (_posY < _height) {
	_posY = 0;
	} else {
	_posY -= _height;
	}
	}

	public void pageDown() {
	_posY += _height;
	}

	}

	public void setStopReadingInput(boolean b) {
	_stopReadingInput.set(true);
	}

	}