Arduino/app/src/processing/app/EditorConsole.java at master · kenstack/Arduino

460 lines (382 loc) · 14.8 KB
/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
  Part of the Processing project - http://processing.org
  Copyright (c) 2004-06 Ben Fry and Casey Reas
  Copyright (c) 2001-04 Massachusetts Institute of Technology
  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software Foundation,
  Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
package processing.app;
import static processing.app.I18n._;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import javax.swing.*;
import javax.swing.text.*;
import java.util.*;
 * Message console that sits below the editing area.
 * Debugging this class is tricky... If it's throwing exceptions,
 * don't take over System.err, and debug while watching just System.out
 * or just write println() or whatever directly to systemOut or systemErr.
public class EditorConsole extends JScrollPane {
  Editor editor;
  JTextPane consoleTextPane;
  BufferedStyledDocument consoleDoc;
  MutableAttributeSet stdStyle;
  MutableAttributeSet errStyle;
  int maxLineCount;
  static File errFile;
  static File outFile;
  static File tempFolder;
  // Single static instance shared because there's only one real System.out.
  // Within the input handlers, the currentConsole variable will be used to
  // echo things to the correct location.
  static public PrintStream systemOut;
  static public PrintStream systemErr;
  static PrintStream consoleOut;
  static PrintStream consoleErr;
  static OutputStream stdoutFile;
  static OutputStream stderrFile;
  static EditorConsole currentConsole;
  public EditorConsole(Editor editor) {
    this.editor = editor;
    maxLineCount = Preferences.getInteger("console.length");
    consoleDoc = new BufferedStyledDocument(10000, maxLineCount);
    consoleTextPane = new JTextPane(consoleDoc);
    consoleTextPane.setEditable(false);
    // necessary?
    MutableAttributeSet standard = new SimpleAttributeSet();
    StyleConstants.setAlignment(standard, StyleConstants.ALIGN_LEFT);
    consoleDoc.setParagraphAttributes(0, 0, standard, true);
    // build styles for different types of console output
    Color bgColor    = Theme.getColor("console.color");
    Color fgColorOut = Theme.getColor("console.output.color");
    Color fgColorErr = Theme.getColor("console.error.color");
    Font consoleFont = Theme.getFont("console.font");
    Font editorFont = Preferences.getFont("editor.font");
    Font font = new Font(consoleFont.getName(), consoleFont.getStyle(), editorFont.getSize());
    stdStyle = new SimpleAttributeSet();
    StyleConstants.setForeground(stdStyle, fgColorOut);
    StyleConstants.setBackground(stdStyle, bgColor);
    StyleConstants.setFontSize(stdStyle, font.getSize());
    StyleConstants.setFontFamily(stdStyle, font.getFamily());
    StyleConstants.setBold(stdStyle, font.isBold());
    StyleConstants.setItalic(stdStyle, font.isItalic());
    errStyle = new SimpleAttributeSet();
    StyleConstants.setForeground(errStyle, fgColorErr);
    StyleConstants.setBackground(errStyle, bgColor);
    StyleConstants.setFontSize(errStyle, font.getSize());
    StyleConstants.setFontFamily(errStyle, font.getFamily());
    StyleConstants.setBold(errStyle, font.isBold());
    StyleConstants.setItalic(errStyle, font.isItalic());
    consoleTextPane.setBackground(bgColor);
    // add the jtextpane to this scrollpane
    this.setViewportView(consoleTextPane);
    // calculate height of a line of text in pixels
    // and size window accordingly
    FontMetrics metrics = this.getFontMetrics(font);
    int height = metrics.getAscent() + metrics.getDescent();
    int lines = Preferences.getInteger("console.lines"); //, 4);
    int sizeFudge = 6; //10; // unclear why this is necessary, but it is
    setPreferredSize(new Dimension(1024, (height * lines) + sizeFudge));
    setMinimumSize(new Dimension(1024, (height * 4) + sizeFudge));
    if (systemOut == null) {
      systemOut = System.out;
      systemErr = System.err;
      // Create a temporary folder which will have a randomized name. Has to 
      // be randomized otherwise another instance of Processing (or one of its 
      // sister IDEs) might collide with the file causing permissions problems. 
      // The files and folders are not deleted on exit because they may be 
      // needed for debugging or bug reporting.
      tempFolder = Base.createTempFolder("console");
      tempFolder.deleteOnExit();
      try {
        String outFileName = Preferences.get("console.output.file");
        if (outFileName != null) {
          outFile = new File(tempFolder, outFileName);
          outFile.deleteOnExit();
          stdoutFile = new FileOutputStream(outFile);
        String errFileName = Preferences.get("console.error.file");
        if (errFileName != null) {
          errFile = new File(tempFolder, errFileName);
          errFile.deleteOnExit();
          stderrFile = new FileOutputStream(errFile);
      } catch (IOException e) {
        Base.showWarning(_("Console Error"),
                         _("A problem occurred while trying to open the\nfiles used to store the console output."), e);
      consoleOut = new PrintStream(new EditorConsoleStream(false));
      consoleErr = new PrintStream(new EditorConsoleStream(true));
      if (Preferences.getBoolean("console")) {
        try {
          System.setOut(consoleOut);
          System.setErr(consoleErr);
        } catch (Exception e) {
          e.printStackTrace(systemOut);
    // to fix ugliness.. normally macosx java 1.3 puts an
    // ugly white border around this object, so turn it off.
    if (Base.isMacOS()) {
      setBorder(null);
    // periodically post buffered messages to the console
    // should the interval come from the preferences file?
    new javax.swing.Timer(250, new ActionListener() {
      public void actionPerformed(ActionEvent evt) {
        // only if new text has been added
        if (consoleDoc.hasAppendage) {
          // insert the text that's been added in the meantime
          consoleDoc.insertAll();
          // always move to the end of the text as it's added
          consoleTextPane.setCaretPosition(consoleDoc.getLength());
    }).start();
  static public void setEditor(Editor editor) {
    currentConsole = editor.console;
   * Close the streams so that the temporary files can be deleted.
   * File.deleteOnExit() cannot be used because the stdout and stderr
   * files are inside a folder, and have to be deleted before the
   * folder itself is deleted, which can't be guaranteed when using
   * the deleteOnExit() method.
  public void handleQuit() {
    // replace original streams to remove references to console's streams
    System.setOut(systemOut);
    System.setErr(systemErr);
    // close the PrintStream
    consoleOut.close();
    consoleErr.close();
    // also have to close the original FileOutputStream
    // otherwise it won't be shut down completely
      stdoutFile.close();
      stderrFile.close();
    } catch (IOException e) {
      e.printStackTrace(systemOut);
    outFile.delete();
    errFile.delete();
    tempFolder.delete();
  public void write(byte b[], int offset, int length, boolean err) {
    // we could do some cross platform CR/LF mangling here before outputting
    // add text to output document
    message(new String(b, offset, length), err, false);
  // added sync for 0091.. not sure if it helps or hinders
  synchronized public void message(String what, boolean err, boolean advance) {
    if (err) {
      systemErr.print(what);
      //systemErr.print("CE" + what);
    } else {
      systemOut.print(what);
      //systemOut.print("CO" + what);
    if (advance) {
      appendText("\n", err);
      if (err) {
        systemErr.println();
      } else {
        systemOut.println();
    // to console display    
    appendText(what, err);
    // moved down here since something is punting
   * Append a piece of text to the console.
   * Swing components are NOT thread-safe, and since the MessageSiphon
   * instantiates new threads, and in those callbacks, they often print
   * output to stdout and stderr, which are wrapped by EditorConsoleStream
   * and eventually leads to EditorConsole.appendText(), which directly
   * updates the Swing text components, causing deadlock.
   * Updates are buffered to the console and displayed at regular
   * intervals on Swing's event-dispatching thread. (patch by David Mellis)
  synchronized private void appendText(String txt, boolean e) {
    consoleDoc.appendString(txt, e ? errStyle : stdStyle);
  public void clear() {
      consoleDoc.remove(0, consoleDoc.getLength());
    } catch (BadLocationException e) {
      // ignore the error otherwise this will cause an infinite loop
      // maybe not a good idea in the long run?
  // . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
  private static class EditorConsoleStream extends OutputStream {
    //static EditorConsole current;
    final boolean err; // whether stderr or stdout
    final byte single[] = new byte[1];
    public EditorConsoleStream(boolean err) {
      this.err = err;
    public void close() { }
    public void flush() { }
    public void write(byte b[]) {  // appears never to be used
      if (currentConsole != null) {
        currentConsole.write(b, 0, b.length, err);
      } else {
        try {
          if (err) {
            systemErr.write(b);
          } else {
            systemOut.write(b);
        } catch (IOException e) { }  // just ignore, where would we write?
      OutputStream echo = err ? stderrFile : stdoutFile;
      if (echo != null) {
        try {
          echo.write(b);
          echo.flush();
        } catch (IOException e) {
          e.printStackTrace();
          echo = null;
    public void write(byte b[], int offset, int length) {
      if (currentConsole != null) {
        currentConsole.write(b, offset, length, err);
      } else {
        try {
          if (err) {
            systemErr.write(b);
          } else {
            systemOut.write(b);
        } catch (IOException e) { }  // just ignore, where would we write?
      OutputStream echo = err ? stderrFile : stdoutFile;
      if (echo != null) {
        try {
          echo.write(b, offset, length);
          echo.flush();
        } catch (IOException e) {
          e.printStackTrace();
          echo = null;
    public void write(int b) {
      single[0] = (byte)b;
      if (currentConsole != null) {
        currentConsole.write(single, 0, 1, err);
      } else {
        // redirect for all the extra handling above
        write(new byte[] { (byte) b }, 0, 1);
      OutputStream echo = err ? stderrFile : stdoutFile;
      if (echo != null) {
        try {
          echo.write(b);
          echo.flush();
        } catch (IOException e) {
          e.printStackTrace();
          echo = null;
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
 * Buffer updates to the console and output them in batches. For info, see:
 * http://java.sun.com/products/jfc/tsc/articles/text/element_buffer and
 * http://javatechniques.com/public/java/docs/gui/jtextpane-speed-part2.html
 * appendString() is called from multiple threads, and insertAll from the
 * swing event thread, so they need to be synchronized
class BufferedStyledDocument extends DefaultStyledDocument {
  ArrayList<ElementSpec> elements = new ArrayList<ElementSpec>();
  int maxLineLength, maxLineCount;
  int currentLineLength = 0;
  boolean needLineBreak = false;
  boolean hasAppendage = false;
  public BufferedStyledDocument(int maxLineLength, int maxLineCount) {
    this.maxLineLength = maxLineLength;
    this.maxLineCount = maxLineCount;
  /** buffer a string for insertion at the end of the DefaultStyledDocument */
  public synchronized void appendString(String str, AttributeSet a) {
    // do this so that it's only updated when needed (otherwise console
    // updates every 250 ms when an app isn't even running.. see bug 180)
    hasAppendage = true;
    // process each line of the string
    while (str.length() > 0) {
      // newlines within an element have (almost) no effect, so we need to
      // replace them with proper paragraph breaks (start and end tags)
      if (needLineBreak || currentLineLength > maxLineLength) {
        elements.add(new ElementSpec(a, ElementSpec.EndTagType));
        elements.add(new ElementSpec(a, ElementSpec.StartTagType));
        currentLineLength = 0;
      if (str.indexOf('\n') == -1) {
        elements.add(new ElementSpec(a, ElementSpec.ContentType,
          str.toCharArray(), 0, str.length()));
        currentLineLength += str.length();
        needLineBreak = false;
        str = str.substring(str.length()); // eat the string
      } else {
        elements.add(new ElementSpec(a, ElementSpec.ContentType,
          str.toCharArray(), 0, str.indexOf('\n') + 1));
        needLineBreak = true;
        str = str.substring(str.indexOf('\n') + 1); // eat the line
  /** insert the buffered strings */
  public synchronized void insertAll() {
    ElementSpec[] elementArray = new ElementSpec[elements.size()];
    elements.toArray(elementArray);
      // check how many lines have been used so far
      // if too many, shave off a few lines from the beginning
      Element element = super.getDefaultRootElement();
      int lineCount = element.getElementCount();
      int overage = lineCount - maxLineCount;
      if (overage > 0) {
        // if 1200 lines, and 1000 lines is max,
        // find the position of the end of the 200th line
        //systemOut.println("overage is " + overage);
        Element lineElement = element.getElement(overage);
        if (lineElement == null) return;  // do nuthin
        int endOffset = lineElement.getEndOffset();
        // remove to the end of the 200th line
        super.remove(0, endOffset);
      super.insert(super.getLength(), elementArray);
    } catch (BadLocationException e) {
      // ignore the error otherwise this will cause an infinite loop
      // maybe not a good idea in the long run?
    elements.clear();
    hasAppendage = false;
Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

EditorConsole.java

Latest commit

History

EditorConsole.java

File metadata and controls
