/** Check whether the key used for multiple selections is down. */
private boolean isMultiselectionKeyDown(MouseEvent evt) {
if (Config.isMacOS()) {
return evt.isShiftDown() || evt.isMetaDown();
} else {
return evt.isShiftDown() || evt.isControlDown();
}
}
/**
* Gets the button for the mouse event. This will also translate CTRL-clicks on mac into mouse
* button three.
*/
private int getButton(MouseEvent e) {
int button = e.getButton();
if (Config.isMacOS() && button == MouseEvent.BUTTON1) {
// Simulate right click on Macs that use CTRL click for right
// clicks. Would be nice if we could use isPopupTrigger instead, but
// that only works for mouse pressed.
if ((e.getModifiersEx() & MouseEvent.CTRL_DOWN_MASK) == MouseEvent.CTRL_DOWN_MASK) {
button = MouseEvent.BUTTON3;
}
}
return button;
}
/**
* The Frame part of the Terminal window used for I/O when running programs under BlueJ.
*
* @author Michael Kolling
* @author Philip Stevens
*/
@SuppressWarnings("serial")
public final class Terminal extends JFrame
implements KeyListener, BlueJEventListener, DebuggerTerminal {
private static final String WINDOWTITLE =
Config.getApplicationName() + ": " + Config.getString("terminal.title");
private static final int SHORTCUT_MASK = Toolkit.getDefaultToolkit().getMenuShortcutKeyMask();
// private static final int ALT_SHORTCUT_MASK =
// SHORTCUT_MASK == Event.CTRL_MASK ? Event.CTRL_MASK : Event.META_MASK;
private static final String TERMINALFONTPROPNAME = "bluej.terminal.font";
private static final String TERMINALFONTSIZEPROPNAME = "bluej.editor.fontsize";
private static final String RECORDMETHODCALLSPROPNAME = "bluej.terminal.recordcalls";
private static final String CLEARONMETHODCALLSPROPNAME = "bluej.terminal.clearscreen";
private static final String UNLIMITEDBUFFERINGCALLPROPNAME = "bluej.terminal.buffering";
// initialise to config value or zero.
private static int terminalFontSize =
Config.getPropInteger(TERMINALFONTSIZEPROPNAME, PrefMgr.getEditorFontSize());
private static boolean isMacOs = Config.isMacOS();
// -- instance --
private Project project;
private TermTextArea text;
private TermTextArea errorText;
private JScrollPane errorScrollPane;
private JScrollPane scrollPane;
private JSplitPane splitPane;
private boolean isActive = false;
private static boolean recordMethodCalls = Config.getPropBoolean(RECORDMETHODCALLSPROPNAME);
private static boolean clearOnMethodCall = Config.getPropBoolean(CLEARONMETHODCALLSPROPNAME);
private static boolean unlimitedBufferingCall =
Config.getPropBoolean(UNLIMITEDBUFFERINGCALLPROPNAME);
private boolean newMethodCall = true;
private boolean errorShown = false;
private InputBuffer buffer;
private JCheckBoxMenuItem autoClear;
private JCheckBoxMenuItem recordCalls;
private JCheckBoxMenuItem unlimitedBuffering;
private Reader in = new TerminalReader();
private Writer out = new TerminalWriter(false);
private Writer err = new TerminalWriter(true);
/** Used for lazy initialisation */
private boolean initialised = false;
/** Create a new terminal window with default specifications. */
public Terminal(Project project) {
super(WINDOWTITLE + " - " + project.getProjectName());
this.project = project;
BlueJEvent.addListener(this);
}
/** Get the terminal font */
private static Font getTerminalFont() {
// reload terminal fontsize from configurations.
terminalFontSize = Config.getPropInteger(TERMINALFONTSIZEPROPNAME, PrefMgr.getEditorFontSize());
return Config.getFont(TERMINALFONTPROPNAME, "Monospaced", terminalFontSize);
}
/*
* Set the terminal font size to equal either the passed parameter, or the
* editor font size if the passed parameter is too low. Place the updated
* value into the configuration.
*/
public static void setTerminalFontSize(int size) {
if (size <= 6) {
return;
} else {
terminalFontSize = size;
}
Config.putPropInteger(TERMINALFONTSIZEPROPNAME, terminalFontSize);
}
/** Initialise the terminal; create the UI. */
private synchronized void initialise() {
if (!initialised) {
buffer = new InputBuffer(256);
int width = Config.isGreenfoot() ? 80 : Config.getPropInteger("bluej.terminal.width", 80);
int height = Config.isGreenfoot() ? 10 : Config.getPropInteger("bluej.terminal.height", 22);
makeWindow(width, height);
initialised = true;
text.setUnlimitedBuffering(unlimitedBufferingCall);
}
}
/** Show or hide the Terminal window. */
public void showHide(boolean show) {
DataCollector.showHideTerminal(project, show);
initialise();
setVisible(show);
if (show) {
text.requestFocus();
}
}
/** Return true if the window is currently displayed. */
public boolean isShown() {
initialise();
return isShowing();
}
/** Make the window active. */
public void activate(boolean active) {
if (active != isActive) {
initialise();
text.setEditable(active);
if (!active) {
text.getCaret().setVisible(false);
}
isActive = active;
}
}
/** Check whether the terminal is active (accepting input). */
public boolean checkActive() {
return isActive;
}
/** Reset the font according to preferences. */
public void resetFont() {
initialise();
Font terminalFont = getTerminalFont();
text.setFont(terminalFont);
if (errorText != null) {
errorText.setFont(terminalFont);
}
}
/** Clear the terminal. */
public void clear() {
initialise();
text.setText("");
if (errorText != null) {
errorText.setText("");
}
hideErrorPane();
}
/** Save the terminal text to file. */
public void save() {
initialise();
String fileName =
FileUtility.getFileName(
this,
Config.getString("terminal.save.title"),
Config.getString("terminal.save.buttonText"),
null,
false);
if (fileName != null) {
File f = new File(fileName);
if (f.exists()) {
if (DialogManager.askQuestion(this, "error-file-exists") != 0) return;
}
try {
FileWriter writer = new FileWriter(fileName);
text.write(writer);
writer.close();
} catch (IOException ex) {
DialogManager.showError(this, "error-save-file");
}
}
}
public void print() {
PrinterJob job = PrinterJob.getPrinterJob();
int printFontSize = Config.getPropInteger("bluej.fontsize.printText", 10);
Font font = new Font("Monospaced", Font.PLAIN, printFontSize);
if (job.printDialog()) {
TerminalPrinter.printTerminal(job, text, job.defaultPage(), font);
}
}
/** Write some text to the terminal. */
private void writeToPane(boolean stdout, String s) {
prepare();
if (!stdout) showErrorPane();
// The form-feed character should clear the screen.
int n = s.lastIndexOf('\f');
if (n != -1) {
clear();
s = s.substring(n + 1);
}
TermTextArea tta = stdout ? text : errorText;
tta.append(s);
tta.setCaretPosition(tta.getDocument().getLength());
}
public void writeToTerminal(String s) {
writeToPane(true, s);
}
/** Prepare the terminal for I/O. */
private void prepare() {
if (newMethodCall) { // prepare only once per method call
showHide(true);
newMethodCall = false;
} else if (Config.isGreenfoot()) {
// In greenfoot new output should always show the terminal
if (!isVisible()) {
showHide(true);
}
}
}
/** An interactive method call has been made by a user. */
private void methodCall(String callString) {
newMethodCall = false;
if (clearOnMethodCall) {
clear();
}
if (recordMethodCalls) {
text.appendMethodCall(callString + "\n");
}
newMethodCall = true;
}
private void constructorCall(InvokerRecord ir) {
newMethodCall = false;
if (clearOnMethodCall) {
clear();
}
if (recordMethodCalls) {
String callString =
ir.getResultTypeString() + " " + ir.getResultName() + " = " + ir.toExpression() + ";";
text.appendMethodCall(callString + "\n");
}
newMethodCall = true;
}
private void methodResult(ExecutionEvent event) {
if (recordMethodCalls) {
String result = null;
String resultType = event.getResult();
if (resultType == ExecutionEvent.NORMAL_EXIT) {
DebuggerObject object = event.getResultObject();
if (object != null) {
if (event.getClassName() != null && event.getMethodName() == null) {
// Constructor call - the result object is the created object.
// Don't display the result separately:
return;
} else {
// if the method returns a void, we must handle it differently
if (object.isNullObject()) {
return; // Don't show result of void calls
} else {
// other - the result object is a wrapper with a single result field
DebuggerField resultField = object.getField(0);
result = " returned " + resultField.getType().toString(true) + " ";
result += resultField.getValueString();
}
}
}
} else if (resultType == ExecutionEvent.EXCEPTION_EXIT) {
result = " Exception occurred.";
} else if (resultType == ExecutionEvent.TERMINATED_EXIT) {
result = " VM terminated.";
}
if (result != null) {
text.appendMethodCall(result + "\n");
}
}
}
/** Return the input stream that can be used to read from this terminal. */
public Reader getReader() {
return in;
}
/** Return the output stream that can be used to write to this terminal */
public Writer getWriter() {
return out;
}
/** Return the output stream that can be used to write error output to this terminal */
public Writer getErrorWriter() {
return err;
}
// ---- KeyListener interface ----
@Override
public void keyPressed(KeyEvent event) {
if (isMacOs) {
handleFontsizeKeys(event, event.getKeyCode());
}
}
@Override
public void keyReleased(KeyEvent event) {}
/**
* Handle the keys which change the terminal font size.
*
* @param event The key event (key pressed/released/typed)
* @param ch The key code (for pressed/release events) or character (for key typed events)
*/
private boolean handleFontsizeKeys(KeyEvent event, int ch) {
boolean handled = false;
// Note the following works because VK_EQUALS, VK_PLUS and VK_MINUS
// are actually defined as their ASCII (and thus unicode) equivalent.
// Since they are final constants this cannot become untrue in the
// future.
switch (ch) {
case KeyEvent.VK_EQUALS: // increase the font size
case KeyEvent.VK_PLUS: // increase the font size (non-uk keyboards)
if (event.getModifiers() == SHORTCUT_MASK) {
PrefMgr.setEditorFontSize(terminalFontSize + 1);
event.consume();
handled = true;
break;
}
case KeyEvent.VK_MINUS: // decrease the font size
if (event.getModifiers() == SHORTCUT_MASK) {
PrefMgr.setEditorFontSize(terminalFontSize - 1);
event.consume();
handled = true;
break;
}
}
return handled;
}
@Override
public void keyTyped(KeyEvent event) {
// We handle most things we are interested in here. The InputMap filters out
// most other unwanted actions (but allows copy/paste).
char ch = event.getKeyChar();
if ((!isMacOs) && handleFontsizeKeys(event, ch)) {
// Note: On Mac OS with Java 7+, we don't see command+= / command+- as a
// key-typed event and so we handle it in keyReleased instead.
return;
}
if ((event.getModifiers() & Event.META_MASK) != 0) {
return; // return without consuming the event
}
if (isActive) {
switch (ch) {
case 4: // CTRL-D (unix/Mac EOF)
case 26: // CTRL-Z (DOS/Windows EOF)
buffer.signalEOF();
writeToTerminal("\n");
event.consume();
break;
case '\b': // backspace
if (buffer.backSpace()) {
try {
int length = text.getDocument().getLength();
text.replaceRange("", length - 1, length);
} catch (Exception exc) {
Debug.reportError("bad location " + exc);
}
}
event.consume();
break;
case '\r': // carriage return
case '\n': // newline
if (buffer.putChar('\n')) {
writeToTerminal(String.valueOf(ch));
buffer.notifyReaders();
}
event.consume();
break;
default:
if (ch >= 32) {
if (buffer.putChar(ch)) {
writeToTerminal(String.valueOf(ch));
}
event.consume();
}
break;
}
}
}
// ---- BlueJEventListener interface ----
/**
* Called when a BlueJ event is raised. The event can be any BlueJEvent type. The implementation
* of this method should check first whether the event type is of interest an return immediately
* if it isn't.
*
* @param eventId A constant identifying the event. One of the event id constants defined in
* BlueJEvent.
* @param arg An event specific parameter. See BlueJEvent for definition.
*/
@Override
public void blueJEvent(int eventId, Object arg) {
initialise();
if (eventId == BlueJEvent.METHOD_CALL) {
InvokerRecord ir = (InvokerRecord) arg;
if (ir.getResultName() != null) {
constructorCall(ir);
} else {
boolean isVoid = ir.hasVoidResult();
if (isVoid) {
methodCall(ir.toStatement());
} else {
methodCall(ir.toExpression());
}
}
} else if (eventId == BlueJEvent.EXECUTION_RESULT) {
methodResult((ExecutionEvent) arg);
}
}
// ---- make window frame ----
/** Create the Swing window. */
private void makeWindow(int columns, int rows) {
Image icon = BlueJTheme.getIconImage();
if (icon != null) {
setIconImage(icon);
}
text = new TermTextArea(rows, columns, buffer, project, this, false);
final InputMap origInputMap = text.getInputMap();
text.setInputMap(
JComponent.WHEN_FOCUSED,
new InputMap() {
{
setParent(origInputMap);
}
@Override
public Object get(KeyStroke keyStroke) {
Object actionName = super.get(keyStroke);
if (actionName == null) {
return null;
}
char keyChar = keyStroke.getKeyChar();
if (keyChar == KeyEvent.CHAR_UNDEFINED || keyChar < 32) {
// We might want to filter the action
if ("copy-to-clipboard".equals(actionName)) {
return actionName;
}
if ("paste-from-clipboard".equals(actionName)) {
// Handled via paste() in TermTextArea
return actionName;
}
return PrefMgr.getFlag(PrefMgr.ACCESSIBILITY_SUPPORT) ? actionName : null;
}
return actionName;
}
});
scrollPane = new JScrollPane(text);
text.setFont(getTerminalFont());
text.setEditable(false);
text.setMargin(new Insets(6, 6, 6, 6));
text.addKeyListener(this);
getContentPane().add(scrollPane, BorderLayout.CENTER);
setJMenuBar(makeMenuBar());
// Close Action when close button is pressed
addWindowListener(
new WindowAdapter() {
@Override
public void windowClosing(WindowEvent event) {
Window win = (Window) event.getSource();
// don't allow them to close the window if the debug machine
// is running.. tries to stop them from closing down the
// input window before finishing off input in the terminal
if (project != null) {
if (project.getDebugger().getStatus() == Debugger.RUNNING) return;
}
DataCollector.showHideTerminal(project, false);
win.setVisible(false);
}
});
// save position when window is moved
addComponentListener(
new ComponentAdapter() {
@Override
public void componentMoved(ComponentEvent event) {
Config.putLocation("bluej.terminal", getLocation());
}
});
setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
setLocation(Config.getLocation("bluej.terminal"));
pack();
}
/** Create a second scrolled text area to the window, for error output. */
private void createErrorPane() {
errorText = new TermTextArea(Config.isGreenfoot() ? 20 : 5, 80, null, project, this, true);
errorScrollPane = new JScrollPane(errorText);
errorText.setFont(getTerminalFont());
errorText.setEditable(false);
errorText.setMargin(new Insets(6, 6, 6, 6));
errorText.setUnlimitedBuffering(true);
splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT, scrollPane, errorScrollPane);
}
/** Show the errorPane for error output */
private void showErrorPane() {
if (errorShown) {
return;
}
// the first time the errortext is shown we need to pack() it
// to make it have the right size.
boolean isFirstShow = false;
if (errorText == null) {
isFirstShow = true;
createErrorPane();
}
getContentPane().remove(scrollPane);
// We want to know if it is not the first time
// This means a "clear" has been used to remove the splitpane
// when this re-adds the scrollPane to the terminal area
// it implicitly removes it from the splitpane as it can only have one
// owner. The side-effect of this is the splitpane's
// top component becomes null.
if (!isFirstShow) splitPane.setTopComponent(scrollPane);
getContentPane().add(splitPane, BorderLayout.CENTER);
splitPane.resetToPreferredSizes();
if (isFirstShow) {
pack();
} else {
validate();
}
errorShown = true;
}
/** Hide the pane with the error output. */
private void hideErrorPane() {
if (!errorShown) {
return;
}
getContentPane().remove(splitPane);
getContentPane().add(scrollPane, BorderLayout.CENTER);
errorShown = false;
validate();
}
/** Create the terminal's menubar, all menus and items. */
private JMenuBar makeMenuBar() {
JMenuBar menubar = new JMenuBar();
JMenu menu = new JMenu(Config.getString("terminal.options"));
JMenuItem item;
item = menu.add(new ClearAction());
item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_K, SHORTCUT_MASK));
item = menu.add(getCopyAction());
item.setText(Config.getString("terminal.copy"));
item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_C, SHORTCUT_MASK));
item = menu.add(new SaveAction());
item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S, SHORTCUT_MASK));
menu.add(new PrintAction());
menu.add(new JSeparator());
autoClear = new JCheckBoxMenuItem(new AutoClearAction());
autoClear.setSelected(clearOnMethodCall);
menu.add(autoClear);
recordCalls = new JCheckBoxMenuItem(new RecordCallAction());
recordCalls.setSelected(recordMethodCalls);
menu.add(recordCalls);
unlimitedBuffering = new JCheckBoxMenuItem(new BufferAction());
unlimitedBuffering.setSelected(unlimitedBufferingCall);
menu.add(unlimitedBuffering);
menu.add(new JSeparator());
item = menu.add(new CloseAction());
item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_W, SHORTCUT_MASK));
menubar.add(menu);
return menubar;
}
private class ClearAction extends AbstractAction {
public ClearAction() {
super(Config.getString("terminal.clear"));
}
public void actionPerformed(ActionEvent e) {
clear();
}
}
private class SaveAction extends AbstractAction {
public SaveAction() {
super(Config.getString("terminal.save"));
}
public void actionPerformed(ActionEvent e) {
save();
}
}
private class PrintAction extends AbstractAction {
public PrintAction() {
super(Config.getString("terminal.print"));
}
public void actionPerformed(ActionEvent e) {
print();
}
}
private class CloseAction extends AbstractAction {
public CloseAction() {
super(Config.getString("terminal.close"));
}
public void actionPerformed(ActionEvent e) {
showHide(false);
}
}
private Action getCopyAction() {
Action[] textActions = text.getActions();
for (int i = 0; i < textActions.length; i++) {
if (textActions[i].getValue(Action.NAME).equals("copy-to-clipboard")) {
return textActions[i];
}
}
return null;
}
private class AutoClearAction extends AbstractAction {
public AutoClearAction() {
super(Config.getString("terminal.clearScreen"));
}
public void actionPerformed(ActionEvent e) {
clearOnMethodCall = autoClear.isSelected();
Config.putPropBoolean(CLEARONMETHODCALLSPROPNAME, clearOnMethodCall);
}
}
private class RecordCallAction extends AbstractAction {
public RecordCallAction() {
super(Config.getString("terminal.recordCalls"));
}
public void actionPerformed(ActionEvent e) {
recordMethodCalls = recordCalls.isSelected();
Config.putPropBoolean(RECORDMETHODCALLSPROPNAME, recordMethodCalls);
}
}
private class BufferAction extends AbstractAction {
public BufferAction() {
super(Config.getString("terminal.buffering"));
}
public void actionPerformed(ActionEvent e) {
unlimitedBufferingCall = unlimitedBuffering.isSelected();
text.setUnlimitedBuffering(unlimitedBufferingCall);
Config.putPropBoolean(UNLIMITEDBUFFERINGCALLPROPNAME, unlimitedBufferingCall);
}
}
/** A Reader which reads from the terminal. */
private class TerminalReader extends Reader {
public int read(char[] cbuf, int off, int len) {
initialise();
int charsRead = 0;
while (charsRead < len) {
cbuf[off + charsRead] = buffer.getChar();
charsRead++;
if (buffer.isEmpty()) break;
}
return charsRead;
}
@Override
public boolean ready() {
return !buffer.isEmpty();
}
public void close() {}
}
/**
* A writer which writes to the terminal. It can be flagged for error output. The idea is that
* error output could be presented differently from standard output.
*/
private class TerminalWriter extends Writer {
private boolean isErrorOut;
TerminalWriter(boolean isError) {
super();
isErrorOut = isError;
}
public void write(final char[] cbuf, final int off, final int len) {
try {
// We use invokeAndWait so that terminal output is limited to
// the processing speed of the event queue. This means the UI
// will still respond to user input even if the output is really
// gushing.
EventQueue.invokeAndWait(
new Runnable() {
public void run() {
initialise();
writeToPane(!isErrorOut, new String(cbuf, off, len));
}
});
} catch (InvocationTargetException ite) {
ite.printStackTrace();
} catch (InterruptedException ie) {
}
}
public void flush() {}
public void close() {}
}
}