com.google.eclipse.tm.terminal/src/com/google/eclipse/tm/internal/terminal/textcanvas/TextCanvas.java - elt - Git at Google

 /*******************************************************************************
  * Copyright (c) 2007, 2011 Wind River Systems, Inc. and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *******************************************************************************/
 package com.google.eclipse.tm.internal.terminal.textcanvas;

 import org.eclipse.swt.SWT;
 import org.eclipse.swt.dnd.*;
 import org.eclipse.swt.events.*;
 import org.eclipse.swt.graphics.*;
 import org.eclipse.swt.widgets.Composite;

 /**
  * A cell oriented Canvas. Maintains a list of "cells". It can either be vertically or horizontally scrolled. The
  * CellRenderer is responsible for painting the cell.
  */
 public class TextCanvas extends GridCanvas {
   private final ITextCanvasModel cellCanvasModel;
   private final ILinelRenderer cellRenderer;
   private boolean scrollLockOn;
   private Point draggingStart;
   private Point draggingEnd;
   private boolean hasSelection;
   private ResizeListener resizeListener;

   // The minSize is meant to determine the minimum size of the backing store (grid) into which remote data is rendered.
   // If the viewport is smaller than that minimum size, the backing store size remains at the minSize,and a scrollbar is
   // shown instead. In reality, this has the following issues or effects today:
   //
   // (a) Bug 281328: For very early data coming in before the widget is realized, the minSize determines into what
   // initial grid that is rendered. See also {@link #addResizeHandler(ResizeListener)}.
   //
   // (b) Bug 294468: Since we have redraw and size computation problems with horizontal scrollers, for now the
   // minColumns must be small enough to avoid a horizontal scroller appearing in most cases.
   //
   // (c) Bug 294327: Since we have problems with the vertical scroller showing the correct location, minLines must be
   // small enough to avoid a vertical scroller or new data may be rendered off-screen.
   //
   // As a compromise, we have been working with a 20x4 since the terminal inception, though many users would want a
   // 80x24 minSize and backing store.

   // Pros and cons of the small minsize:
   // + consistent "remote size==viewport size", vi works as expected
   // - dumb terminals which expect 80x24 render garbled on small viewport
   //
   // If bug 294468 were resolved, an 80 wide minSize would be preferrable since it allows switching the terminal
   // viewport small/large as needed, without destroying the backing store. For a complete solution, bug 196462 tracks
   // the request for a user-defined fixed-widow-size-mode.
   private int minColumns = 80;

   private int minLines = 4;
   private boolean cursorEnabled;
   private boolean resizing;

   /**
    * Create a new CellCanvas with the given SWT style bits. (SWT.H_SCROLL and SWT.V_SCROLL are automatically added).
    */
   public TextCanvas(Composite parent, ITextCanvasModel model, int style, ILinelRenderer cellRenderer) {
     super(parent, style | SWT.H_SCROLL | SWT.V_SCROLL);
     this.cellRenderer = cellRenderer;
     setCellWidth(cellRenderer.getCellWidth());
     setCellHeight(cellRenderer.getCellHeight());
     cellCanvasModel = model;
     cellCanvasModel.addCellCanvasModelListener(new ITextCanvasModelListener() {
       @Override public void rangeChanged(int col, int line, int width, int height) {
         repaintRange(col, line, width, height);
       }

       @Override public void dimensionsChanged(int cols, int rows) {
         calculateGrid();
       }

       @Override public void terminalDataChanged() {
         if (!isDisposed() && !resizing) {
           // scroll to end (unless scroll lock is active)
           calculateGrid();
           scrollToEnd();
         }
       }
     });
     // let the cursor blink if the text canvas gets the focus...
     addFocusListener(new FocusListener() {
       @Override public void focusGained(FocusEvent e) {
         cellCanvasModel.setCursorEnabled(cursorEnabled);
       }

       @Override public void focusLost(FocusEvent e) {
         cellCanvasModel.setCursorEnabled(false);
       }
     });
     addMouseListener(new MouseAdapter() {
       @Override public void mouseDown(MouseEvent e) {
         if (e.button == 1) { // left button
           draggingStart = screenPointToCell(e.x, e.y);
           hasSelection = false;
           if ((e.stateMask & SWT.SHIFT) != 0) {
             Point anchor = cellCanvasModel.getSelectionAnchor();
             if (anchor != null) {
               draggingStart = anchor;
             }
           } else {
             cellCanvasModel.setSelectionAnchor(draggingStart);
           }
           draggingEnd = null;
         }
       }

       @Override public void mouseUp(MouseEvent e) {
         if (e.button == 1) { // left button
           updateHasSelection(e);
           if (hasSelection) {
             setSelection(screenPointToCell(e.x, e.y));
           } else {
             cellCanvasModel.setSelection(-1, -1, -1, -1);
           }
           draggingStart = null;
         }
       }
     });
     addMouseMoveListener(new MouseMoveListener() {
       @Override public void mouseMove(MouseEvent e) {
         if (draggingStart != null) {
           updateHasSelection(e);
           setSelection(screenPointToCell(e.x, e.y));
         }
       }
     });
     serVerticalBarVisible(true);
     setHorizontalBarVisible(false);
   }

   // The user has to drag the mouse to at least one character to make a selection. Once this is done, even a one char
   // selection is OK.
   private void updateHasSelection(MouseEvent e) {
     if (draggingStart != null) {
       Point p = screenPointToCell(e.x, e.y);
       if (draggingStart.x != p.x || draggingStart.y != p.y) {
         hasSelection = true;
       }
     }
   }

   void setSelection(Point p) {
     if (draggingStart != null && !p.equals(draggingEnd)) {
       draggingEnd = p;
       if (compare(p, draggingStart) < 0) {
         // bug 219589 - make sure selection start coordinates are non-negative
         int startColumn = Math.max(0, p.x);
         int startRow = Math.max(p.y, 0);
         cellCanvasModel.setSelection(startRow, draggingStart.y, startColumn, draggingStart.x);
       } else {
         cellCanvasModel.setSelection(draggingStart.y, p.y, draggingStart.x, p.x);
       }
     }
   }

   int compare(Point p1, Point p2) {
     if (p1.equals(p2)) {
       return 0;
     }
     if (p1.y == p2.y) {
       return p1.x > p2.x ? 1 : -1;
     }
     return p1.y > p2.y ? 1 : -1;
   }

   public ILinelRenderer getCellRenderer() {
     return cellRenderer;
   }

   public int getMinColumns() {
     return minColumns;
   }

   public void setMinColumns(int minColumns) {
     this.minColumns = minColumns;
   }

   public int getMinLines() {
     return minLines;
   }

   public void setMinLines(int minLines) {
     this.minLines = minLines;
   }

   protected void onResize(boolean init) {
     if (resizeListener != null) {
       Rectangle bonds = getClientArea();
       int cellHeight = getCellHeight();
       int cellWidth = getCellWidth();
       int lines = bonds.height / cellHeight;
       int columns = bonds.width / cellWidth;
       // When the view is minimized, its size is set to 0 we don't sent this to the terminal!
       if ((lines > 0 && columns > 0) || init) {
         if (columns < minColumns) {
           if (!isHorizontalBarVisble()) {
             setHorizontalBarVisible(true);
             bonds = getClientArea();
             lines = bonds.height / cellHeight;
           }
           columns = minColumns;
         } else if (columns >= minColumns && isHorizontalBarVisble()) {
           setHorizontalBarVisible(false);
           bonds = getClientArea();
           lines = bonds.height / cellHeight;
           columns = bonds.width / cellWidth;
         }
         if (lines < minLines) {
           lines = minLines;
         }
         resizeListener.sizeChanged(lines, columns);
       }
     }
     super.onResize();
     calculateGrid();
   }

   @Override protected void onResize() {
     resizing = true;
     try {
       onResize(false);
     } finally {
       resizing = false;
     }
   }

   private void calculateGrid() {
     Rectangle virtualBounds = getVirtualBounds();
     setRedraw(false);
     try {
       setVirtualExtend(getCols() * getCellWidth(), getRows() * getCellHeight());
       getParent().layout();
       if (resizing) {
         // scroll to end if view port was near last line
         Rectangle viewRect = getViewRectangle();
         if (virtualBounds.height - (viewRect.y + viewRect.height) < getCellHeight() * 2) {
           scrollToEnd();
         }
       }
     } finally {
       setRedraw(true);
     }
   }

   void scrollToEnd() {
     if (!scrollLockOn) {
       int y = -(getRows() * getCellHeight() - getClientArea().height);
       if (y > 0) {
         y = 0;
       }
       Rectangle v = getViewRectangle();
       if (v.y != -y) {
         setVirtualOrigin(v.x, y);
       }
       // make sure the scroll area is correct.
       scrollY(getVerticalBar());
       scrollX(getHorizontalBar());
     }
   }

   public boolean isScrollLockOn() {
     return scrollLockOn;
   }

   public void setScrollLockOn(boolean on) {
     scrollLockOn = on;
   }

   protected void repaintRange(int col, int line, int width, int height) {
     Point origin = cellToOriginOnScreen(col, line);
     Rectangle r = new Rectangle(origin.x, origin.y, width * getCellWidth(), height * getCellHeight());
     repaint(r);
   }

   @Override protected void drawLine(GC gc, int line, int x, int y, int colFirst, int colLast) {
     cellRenderer.drawLine(cellCanvasModel, gc, line, x, y, colFirst, colLast);
   }

   @Override protected Color getTerminalBackgroundColor() {
     return cellRenderer.getDefaultBackgroundColor();
   }

   @Override protected void visibleCellRectangleChanged(int x, int y, int width, int height) {
     cellCanvasModel.setVisibleRectangle(y, x, height, width);
     update();
   }

   @Override protected int getCols() {
     return cellCanvasModel.getTerminalText().getWidth();
   }

   @Override protected int getRows() {
     return cellCanvasModel.getTerminalText().getHeight();
   }

   public String getSelectionText() {
     // TODO -- create a hasSelectionMethod!
     return cellCanvasModel.getSelectedText();
   }

   public void copy() {
     Clipboard clipboard = new Clipboard(getDisplay());
     clipboard.setContents(new Object[] { getSelectionText() }, new Transfer[] { TextTransfer.getInstance() });
     clipboard.dispose();
   }

   public void selectAll() {
     cellCanvasModel.setSelection(
         0, cellCanvasModel.getTerminalText().getHeight(), 0, cellCanvasModel.getTerminalText().getWidth());
     cellCanvasModel.setSelectionAnchor(new Point(0, 0));
   }

   public boolean isEmpty() {
     return false;
   }

   /**
    * Gets notified when the visible size of the terminal changes. This should update the model!
    */
   public static interface ResizeListener {
     void sizeChanged(int lines, int columns);
   }

   public void addResizeHandler(ResizeListener listener) {
     if (resizeListener != null) {
       throw new IllegalArgumentException("There can be at most one listener at the moment!");
     }
     resizeListener = listener;
     // Bug 281328: The very first few characters might be missing in the terminal control if opened and connected
     // programmatically.
     //
     // In case the terminal had not been visible yet or is too small (less than one line visible), the terminal should
     // have a minimum size to avoid RuntimeExceptions.
     Rectangle bonds = getClientArea();
     if (bonds.height < getCellHeight() || bonds.width < getCellWidth()) {
       // Widget not realized yet, or minimized to < 1 item. Just tell the listener our min size.
       resizeListener.sizeChanged(getMinLines(), getMinColumns());
     } else {
       // Widget realized: compute actual size and force telling the listener
       onResize(true);
     }
   }

   public void onFontChange() {
     cellRenderer.onFontChange();
     setCellWidth(cellRenderer.getCellWidth());
     setCellHeight(cellRenderer.getCellHeight());
     calculateGrid();
   }

   public void setInvertedColors(boolean invert) {
     cellRenderer.setInvertedColors(invert);
     redraw();
   }

   /**
    * Indicates whether the cursor is enabled (blinking.) By default the cursor is not enabled.
    *
    * @return {@code true} if the cursor is enabled, {@code false} otherwise.
    */
   public boolean isCursorEnabled() {
     return cursorEnabled;
   }

   /**
    * Enables or disables the cursor (enabling means that the cursor blinks.)
    *
    * @param enabled indicates whether the cursor should be enabled.
    */
   public void setCursorEnabled(boolean enabled) {
     if (enabled != cursorEnabled) {
       cursorEnabled = enabled;
       cellCanvasModel.setCursorEnabled(cursorEnabled);
     }
   }

   public void setColors(RGB background, RGB foreground) {
     cellRenderer.setColors(background, foreground);
     redraw();
   }

   @Override public void setFont(Font font) {
     super.setFont(font);
     cellRenderer.setFont(font);
     redraw();
   }

   @Override public Point screenPointToCell(int x, int y) {
     return super.screenPointToCell(x, y);
   }

   public void setBlinkingCursor(boolean useBlinkingCursor) {
     cellCanvasModel.setBlinkingCursor(useBlinkingCursor);
   }
 }
	/*******************************************************************************
	* Copyright (c) 2007, 2011 Wind River Systems, Inc. and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*******************************************************************************/
	package com.google.eclipse.tm.internal.terminal.textcanvas;

	import org.eclipse.swt.SWT;
	import org.eclipse.swt.dnd.*;
	import org.eclipse.swt.events.*;
	import org.eclipse.swt.graphics.*;
	import org.eclipse.swt.widgets.Composite;

	/**
	* A cell oriented Canvas. Maintains a list of "cells". It can either be vertically or horizontally scrolled. The
	* CellRenderer is responsible for painting the cell.
	*/
	public class TextCanvas extends GridCanvas {
	private final ITextCanvasModel cellCanvasModel;
	private final ILinelRenderer cellRenderer;
	private boolean scrollLockOn;
	private Point draggingStart;
	private Point draggingEnd;
	private boolean hasSelection;
	private ResizeListener resizeListener;

	// The minSize is meant to determine the minimum size of the backing store (grid) into which remote data is rendered.
	// If the viewport is smaller than that minimum size, the backing store size remains at the minSize,and a scrollbar is
	// shown instead. In reality, this has the following issues or effects today:
	//
	// (a) Bug 281328: For very early data coming in before the widget is realized, the minSize determines into what
	// initial grid that is rendered. See also {@link #addResizeHandler(ResizeListener)}.
	//
	// (b) Bug 294468: Since we have redraw and size computation problems with horizontal scrollers, for now the
	// minColumns must be small enough to avoid a horizontal scroller appearing in most cases.
	//
	// (c) Bug 294327: Since we have problems with the vertical scroller showing the correct location, minLines must be
	// small enough to avoid a vertical scroller or new data may be rendered off-screen.
	//
	// As a compromise, we have been working with a 20x4 since the terminal inception, though many users would want a
	// 80x24 minSize and backing store.

	// Pros and cons of the small minsize:
	// + consistent "remote size==viewport size", vi works as expected
	// - dumb terminals which expect 80x24 render garbled on small viewport
	//
	// If bug 294468 were resolved, an 80 wide minSize would be preferrable since it allows switching the terminal
	// viewport small/large as needed, without destroying the backing store. For a complete solution, bug 196462 tracks
	// the request for a user-defined fixed-widow-size-mode.
	private int minColumns = 80;

	private int minLines = 4;
	private boolean cursorEnabled;
	private boolean resizing;

	/**
	* Create a new CellCanvas with the given SWT style bits. (SWT.H_SCROLL and SWT.V_SCROLL are automatically added).
	*/
	public TextCanvas(Composite parent, ITextCanvasModel model, int style, ILinelRenderer cellRenderer) {
	super(parent, style \| SWT.H_SCROLL \| SWT.V_SCROLL);
	this.cellRenderer = cellRenderer;
	setCellWidth(cellRenderer.getCellWidth());
	setCellHeight(cellRenderer.getCellHeight());
	cellCanvasModel = model;
	cellCanvasModel.addCellCanvasModelListener(new ITextCanvasModelListener() {
	@Override public void rangeChanged(int col, int line, int width, int height) {
	repaintRange(col, line, width, height);
	}

	@Override public void dimensionsChanged(int cols, int rows) {
	calculateGrid();
	}

	@Override public void terminalDataChanged() {
	if (!isDisposed() && !resizing) {
	// scroll to end (unless scroll lock is active)
	calculateGrid();
	scrollToEnd();
	}
	}
	});
	// let the cursor blink if the text canvas gets the focus...
	addFocusListener(new FocusListener() {
	@Override public void focusGained(FocusEvent e) {
	cellCanvasModel.setCursorEnabled(cursorEnabled);
	}

	@Override public void focusLost(FocusEvent e) {
	cellCanvasModel.setCursorEnabled(false);
	}
	});
	addMouseListener(new MouseAdapter() {
	@Override public void mouseDown(MouseEvent e) {
	if (e.button == 1) { // left button
	draggingStart = screenPointToCell(e.x, e.y);
	hasSelection = false;
	if ((e.stateMask & SWT.SHIFT) != 0) {
	Point anchor = cellCanvasModel.getSelectionAnchor();
	if (anchor != null) {
	draggingStart = anchor;
	}
	} else {
	cellCanvasModel.setSelectionAnchor(draggingStart);
	}
	draggingEnd = null;
	}
	}

	@Override public void mouseUp(MouseEvent e) {
	if (e.button == 1) { // left button
	updateHasSelection(e);
	if (hasSelection) {
	setSelection(screenPointToCell(e.x, e.y));
	} else {
	cellCanvasModel.setSelection(-1, -1, -1, -1);
	}
	draggingStart = null;
	}
	}
	});
	addMouseMoveListener(new MouseMoveListener() {
	@Override public void mouseMove(MouseEvent e) {
	if (draggingStart != null) {
	updateHasSelection(e);
	setSelection(screenPointToCell(e.x, e.y));
	}
	}
	});
	serVerticalBarVisible(true);
	setHorizontalBarVisible(false);
	}

	// The user has to drag the mouse to at least one character to make a selection. Once this is done, even a one char
	// selection is OK.
	private void updateHasSelection(MouseEvent e) {
	if (draggingStart != null) {
	Point p = screenPointToCell(e.x, e.y);
	if (draggingStart.x != p.x \|\| draggingStart.y != p.y) {
	hasSelection = true;
	}
	}
	}

	void setSelection(Point p) {
	if (draggingStart != null && !p.equals(draggingEnd)) {
	draggingEnd = p;
	if (compare(p, draggingStart) < 0) {
	// bug 219589 - make sure selection start coordinates are non-negative
	int startColumn = Math.max(0, p.x);
	int startRow = Math.max(p.y, 0);
	cellCanvasModel.setSelection(startRow, draggingStart.y, startColumn, draggingStart.x);
	} else {
	cellCanvasModel.setSelection(draggingStart.y, p.y, draggingStart.x, p.x);
	}
	}
	}

	int compare(Point p1, Point p2) {
	if (p1.equals(p2)) {
	return 0;
	}
	if (p1.y == p2.y) {
	return p1.x > p2.x ? 1 : -1;
	}
	return p1.y > p2.y ? 1 : -1;
	}

	public ILinelRenderer getCellRenderer() {
	return cellRenderer;
	}

	public int getMinColumns() {
	return minColumns;
	}

	public void setMinColumns(int minColumns) {
	this.minColumns = minColumns;
	}

	public int getMinLines() {
	return minLines;
	}

	public void setMinLines(int minLines) {
	this.minLines = minLines;
	}

	protected void onResize(boolean init) {
	if (resizeListener != null) {
	Rectangle bonds = getClientArea();
	int cellHeight = getCellHeight();
	int cellWidth = getCellWidth();
	int lines = bonds.height / cellHeight;
	int columns = bonds.width / cellWidth;
	// When the view is minimized, its size is set to 0 we don't sent this to the terminal!
	if ((lines > 0 && columns > 0) \|\| init) {
	if (columns < minColumns) {
	if (!isHorizontalBarVisble()) {
	setHorizontalBarVisible(true);
	bonds = getClientArea();
	lines = bonds.height / cellHeight;
	}
	columns = minColumns;
	} else if (columns >= minColumns && isHorizontalBarVisble()) {
	setHorizontalBarVisible(false);
	bonds = getClientArea();
	lines = bonds.height / cellHeight;
	columns = bonds.width / cellWidth;
	}
	if (lines < minLines) {
	lines = minLines;
	}
	resizeListener.sizeChanged(lines, columns);
	}
	}
	super.onResize();
	calculateGrid();
	}

	@Override protected void onResize() {
	resizing = true;
	try {
	onResize(false);
	} finally {
	resizing = false;
	}
	}

	private void calculateGrid() {
	Rectangle virtualBounds = getVirtualBounds();
	setRedraw(false);
	try {
	setVirtualExtend(getCols() * getCellWidth(), getRows() * getCellHeight());
	getParent().layout();
	if (resizing) {
	// scroll to end if view port was near last line
	Rectangle viewRect = getViewRectangle();
	if (virtualBounds.height - (viewRect.y + viewRect.height) < getCellHeight() * 2) {
	scrollToEnd();
	}
	}
	} finally {
	setRedraw(true);
	}
	}

	void scrollToEnd() {
	if (!scrollLockOn) {
	int y = -(getRows() * getCellHeight() - getClientArea().height);
	if (y > 0) {
	y = 0;
	}
	Rectangle v = getViewRectangle();
	if (v.y != -y) {
	setVirtualOrigin(v.x, y);
	}
	// make sure the scroll area is correct.
	scrollY(getVerticalBar());
	scrollX(getHorizontalBar());
	}
	}

	public boolean isScrollLockOn() {
	return scrollLockOn;
	}

	public void setScrollLockOn(boolean on) {
	scrollLockOn = on;
	}

	protected void repaintRange(int col, int line, int width, int height) {
	Point origin = cellToOriginOnScreen(col, line);
	Rectangle r = new Rectangle(origin.x, origin.y, width * getCellWidth(), height * getCellHeight());
	repaint(r);
	}

	@Override protected void drawLine(GC gc, int line, int x, int y, int colFirst, int colLast) {
	cellRenderer.drawLine(cellCanvasModel, gc, line, x, y, colFirst, colLast);
	}

	@Override protected Color getTerminalBackgroundColor() {
	return cellRenderer.getDefaultBackgroundColor();
	}

	@Override protected void visibleCellRectangleChanged(int x, int y, int width, int height) {
	cellCanvasModel.setVisibleRectangle(y, x, height, width);
	update();
	}

	@Override protected int getCols() {
	return cellCanvasModel.getTerminalText().getWidth();
	}

	@Override protected int getRows() {
	return cellCanvasModel.getTerminalText().getHeight();
	}

	public String getSelectionText() {
	// TODO -- create a hasSelectionMethod!
	return cellCanvasModel.getSelectedText();
	}

	public void copy() {
	Clipboard clipboard = new Clipboard(getDisplay());
	clipboard.setContents(new Object[] { getSelectionText() }, new Transfer[] { TextTransfer.getInstance() });
	clipboard.dispose();
	}

	public void selectAll() {
	cellCanvasModel.setSelection(
	0, cellCanvasModel.getTerminalText().getHeight(), 0, cellCanvasModel.getTerminalText().getWidth());
	cellCanvasModel.setSelectionAnchor(new Point(0, 0));
	}

	public boolean isEmpty() {
	return false;
	}

	/**
	* Gets notified when the visible size of the terminal changes. This should update the model!
	*/
	public static interface ResizeListener {
	void sizeChanged(int lines, int columns);
	}

	public void addResizeHandler(ResizeListener listener) {
	if (resizeListener != null) {
	throw new IllegalArgumentException("There can be at most one listener at the moment!");
	}
	resizeListener = listener;
	// Bug 281328: The very first few characters might be missing in the terminal control if opened and connected
	// programmatically.
	//
	// In case the terminal had not been visible yet or is too small (less than one line visible), the terminal should
	// have a minimum size to avoid RuntimeExceptions.
	Rectangle bonds = getClientArea();
	if (bonds.height < getCellHeight() \|\| bonds.width < getCellWidth()) {
	// Widget not realized yet, or minimized to < 1 item. Just tell the listener our min size.
	resizeListener.sizeChanged(getMinLines(), getMinColumns());
	} else {
	// Widget realized: compute actual size and force telling the listener
	onResize(true);
	}
	}

	public void onFontChange() {
	cellRenderer.onFontChange();
	setCellWidth(cellRenderer.getCellWidth());
	setCellHeight(cellRenderer.getCellHeight());
	calculateGrid();
	}

	public void setInvertedColors(boolean invert) {
	cellRenderer.setInvertedColors(invert);
	redraw();
	}

	/**
	* Indicates whether the cursor is enabled (blinking.) By default the cursor is not enabled.
	*
	* @return {@code true} if the cursor is enabled, {@code false} otherwise.
	*/
	public boolean isCursorEnabled() {
	return cursorEnabled;
	}

	/**
	* Enables or disables the cursor (enabling means that the cursor blinks.)
	*
	* @param enabled indicates whether the cursor should be enabled.
	*/
	public void setCursorEnabled(boolean enabled) {
	if (enabled != cursorEnabled) {
	cursorEnabled = enabled;
	cellCanvasModel.setCursorEnabled(cursorEnabled);
	}
	}

	public void setColors(RGB background, RGB foreground) {
	cellRenderer.setColors(background, foreground);
	redraw();
	}

	@Override public void setFont(Font font) {
	super.setFont(font);
	cellRenderer.setFont(font);
	redraw();
	}

	@Override public Point screenPointToCell(int x, int y) {
	return super.screenPointToCell(x, y);
	}

	public void setBlinkingCursor(boolean useBlinkingCursor) {
	cellCanvasModel.setBlinkingCursor(useBlinkingCursor);
	}
	}