Beispiel #1
0
  /**
   * 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;
  }
  /**
   * Adds a single item to this roles popup menu.
   *
   * <p>This method is used by ClassTarget to add some standard menus as well as by the roles to add
   * menus. It should be overridden with caution.
   *
   * @param menu the popup menu the item is to be added to
   * @param action the action to be registered with this menu item
   * @param itemString the String to be displayed on menu item
   * @param enabled boolean value representing whether item should be enabled
   */
  public void addMenuItem(JPopupMenu menu, Action action, boolean enabled) {
    JMenuItem item;

    item = new JMenuItem();
    item.setAction(action);
    item.setFont(PrefMgr.getPopupMenuFont());
    item.setForeground(envOpColour);
    item.setEnabled(enabled);

    menu.add(item);
  }
  /**
   * Create the menu items for the given members (constructors or methods).
   *
   * @return true if any items were created
   */
  public static boolean createMenuItems(
      JPopupMenu menu,
      CallableView[] members,
      ViewFilter filter,
      int first,
      int last,
      String prefix,
      InvokeListener il) {
    // Debug.message("Inside ClassTarget.createMenuItems\n first = " + first
    // + " last = " + last);
    boolean hasEntries = false;
    JMenuItem item;

    for (int i = first; i < last; i++) {
      try {
        CallableView m = members[last - i - 1];
        if (!filter.accept(m)) continue;
        // Debug.message("createSubMenu - creating MenuItem");

        Action callAction = null;
        if (m instanceof MethodView)
          callAction = new InvokeAction((MethodView) m, il, prefix + m.getLongDesc());
        else if (m instanceof ConstructorView)
          callAction = new ConstructAction((ConstructorView) m, il, prefix + m.getLongDesc());

        if (callAction != null) {
          item = menu.add(callAction);
          item.setFont(PrefMgr.getPopupMenuFont());
          hasEntries = true;
        }
      } catch (Exception e) {
        Debug.reportError("Exception accessing methods: " + e);
        e.printStackTrace();
      }
    }
    return hasEntries;
  }
Beispiel #4
0
/**
 * 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() {}
  }
}
Beispiel #5
0
  /** 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);
  }
 private void addMenuItem(JPopupMenu menu, Action action) {
   JMenuItem item = menu.add(action);
   item.setFont(PrefMgr.getPopupMenuFont());
   item.setForeground(envOpColour);
 }
 /**
  * Sets the value of expanded/collapsed to the current view and to the prefmgr
  *
  * @param expanded
  */
 protected void setExpanded(boolean expanded) {
   // saving the value of the naviview (expanded/collapsed) to the prefmgr
   // so it is there when the next editor may be opened
   PrefMgr.setNaviviewExpanded(expanded);
   this.expanded = expanded;
 }
Beispiel #8
0
/**
 * Class to provide simple UI customisations such as colours and fonts. Specifically created to
 * allow access to default Fonts for user interface components for i18n purposes.
 *
 * @author Bruce Quig
 * @version $Id: BlueJTheme.java 6215 2009-03-30 13:28:25Z polle $
 */
public class BlueJTheme extends DefaultMetalTheme {
  private final FontUIResource controlFont = new FontUIResource(PrefMgr.getStandardFont());
  private final FontUIResource systemFont = new FontUIResource(controlFont);
  private final FontUIResource userFont = new FontUIResource(controlFont);
  private final FontUIResource menuFont = new FontUIResource(PrefMgr.getStandardMenuFont());

  // icon to be used for BlueJ windows
  private static Image iconImage = null;

  // common strings - must be accessed through getOkLabel()
  private static String okayLabel;
  private static String cancelLabel;
  private static String closeLabel;
  private static String continueLabel;

  // a dimension for ok and cancel buttons that is as large as
  // needed to display either
  private static Dimension okCancelDimension;

  // JSplitPane divider width constant
  public static final int splitPaneDividerWidth = 3;

  // Other general spacing constants. We should try to use these for consistency
  public static final int generalSpacingWidth = 5;

  public static final Border generalBorder = BorderFactory.createEmptyBorder(10, 10, 10, 10);

  public static final Border generalBorderWithStatusBar =
      BorderFactory.createEmptyBorder(10, 10, 0, 10);

  public static final Border dialogBorder = BorderFactory.createEmptyBorder(12, 12, 12, 12);

  private static Border roundedShadowBorder;
  private static Border shadowBorder;

  public static final int commandButtonSpacing = 5;
  public static final int commandButtonPadding = 12;

  public static final int componentSpacingSmall = 5;
  public static final int componentSpacingLarge = 11;

  public static final int dialogCommandButtonsVertical = 17;

  /** Name of theme */
  public String getName() {
    return "BlueJTheme";
  }

  public FontUIResource getControlTextFont() {
    return controlFont;
  }

  public FontUIResource getSystemTextFont() {
    return systemFont;
  }

  public FontUIResource getUserTextFont() {
    return userFont;
  }

  public FontUIResource getMenuTextFont() {
    return menuFont;
  }

  /**
   * Get the icon for most BlueJ frames.
   *
   * @return an icon to be used as the frame icon for most BlueJ windows
   */
  public static Image getIconImage() {
    if (iconImage == null) iconImage = Config.getImageAsIcon("image.icon").getImage();

    return iconImage;
  }

  public static void setIconImage(Image newIconImage) {
    iconImage = newIconImage;
  }

  public static String getOkLabel() {
    if (okayLabel == null) {
      okayLabel = Config.getString("okay");
    }
    return okayLabel;
  }

  public static String getCancelLabel() {
    if (cancelLabel == null) {
      cancelLabel = Config.getString("cancel");
    }
    return cancelLabel;
  }

  public static String getCloseLabel() {
    if (closeLabel == null) {
      closeLabel = Config.getString("close");
    }
    return closeLabel;
  }

  public static String getContinueLabel() {
    if (continueLabel == null) {
      continueLabel = Config.getString("continue");
    }
    return continueLabel;
  }

  /**
   * Get a standard BlueJ "ok" button.
   *
   * @return A JButton that says "ok"
   */
  public static JButton getOkButton() {
    computeButtonWidths();

    JButton okButton = new JButton(getOkLabel());
    // try to make the OK, cancel and continue buttons have equal size
    okButton.setPreferredSize(okCancelDimension);
    return okButton;
  }

  /**
   * Get a standard BlueJ "cancel" button.
   *
   * @return A JButton that says "cancel"
   */
  public static JButton getCancelButton() {
    computeButtonWidths();

    JButton cancelButton = new JButton(getCancelLabel());
    // try to make the OK, cancel and continue  buttons have equal size
    cancelButton.setPreferredSize(okCancelDimension);
    return cancelButton;
  }

  /**
   * Get a standard BlueJ "close" button.
   *
   * @return A JButton that says "cancel"
   */
  public static JButton getCloseButton() {
    computeButtonWidths();

    JButton closeButton = new JButton(getCloseLabel());
    // try to make the OK, cancel and continue  buttons have equal size
    closeButton.setPreferredSize(okCancelDimension);
    return closeButton;
  }

  /**
   * Get a standard BlueJ "continue" button.
   *
   * @return A JButton that says "Continue"
   */
  public static JButton getContinueButton() {
    computeButtonWidths();

    JButton continueButton = new JButton(getContinueLabel());
    // try to make the OK, cancel and continue  buttons have equal size
    continueButton.setPreferredSize(okCancelDimension);
    return continueButton;
  }

  public static synchronized Border getRoundedShadowBorder() {
    if (roundedShadowBorder == null) {
      roundedShadowBorder = new RoundedShadowBorder();
    }
    return roundedShadowBorder;
  }

  public static synchronized Border getShadowBorder() {
    if (roundedShadowBorder == null) {
      shadowBorder = new ShadowBorder();
    }
    return roundedShadowBorder;
  }

  /**
   * Computer the maximum width of the ok, cancel and continue buttons and set the okCancelDimension
   * to be representative of that size.
   */
  private static void computeButtonWidths() {
    if (okCancelDimension != null) return;

    JButton okButton = new JButton(getOkLabel());
    JButton cancelButton = new JButton(getCancelLabel());
    JButton continueButton = new JButton(getContinueLabel());

    int maxWidth =
        Math.max(cancelButton.getPreferredSize().width, okButton.getPreferredSize().width);
    maxWidth = Math.max(maxWidth, continueButton.getPreferredSize().width);

    okCancelDimension = new Dimension(maxWidth, okButton.getPreferredSize().height);
  }

  /**
   * A border with rounded corners and a shadow
   *
   * @author Poul Henriksen
   */
  private static class RoundedShadowBorder extends AbstractBorder {
    private Insets insets;
    private ImageIcon topLeftCorner = Config.getImageAsIcon("image.border.topleft");
    private ImageIcon topRightCorner = Config.getImageAsIcon("image.border.topright");
    private ImageIcon bottomLeftCorner = Config.getImageAsIcon("image.border.bottomleft");
    private ImageIcon bottomRightCorner = Config.getImageAsIcon("image.border.bottomright");
    private Color shadowColor = new Color(145, 145, 145);
    private Color backgroundColor = Color.white;
    private Color borderColor = Color.black;
    private int backgroundThickness = 5; // extra space around the frame

    public RoundedShadowBorder() {
      insets = new Insets(0, 0, 0, 0);
      insets.bottom = bottomLeftCorner.getIconHeight() + backgroundThickness;
      insets.top = topLeftCorner.getIconHeight() + backgroundThickness;
      insets.left = topLeftCorner.getIconHeight() + backgroundThickness;
      insets.right = topRightCorner.getIconHeight() + backgroundThickness;
    }

    /**
     * Reinitializes the insets parameter with this Border's current Insets.
     *
     * @param c the component for which this border insets value applies
     * @param insets the object to be reinitialized
     * @return the <code>insets</code> object
     */
    public Insets getBorderInsets(Component c, Insets insets) {
      insets.bottom = this.insets.bottom;
      insets.top = this.insets.top;
      insets.left = this.insets.left;
      insets.right = this.insets.right;
      return insets;
    }

    /**
     * Returns a new <code>Insets</code> instance.
     *
     * @param c the component for which this border insets value applies
     * @return the new <code>Insets</code> object
     */
    public Insets getBorderInsets(Component c) {
      return (Insets) insets.clone();
    }

    /** Returns false. */
    public boolean isBorderOpaque() {
      return false;
    }

    /** Paints the border */
    public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {

      x += backgroundThickness;
      y += backgroundThickness;
      height -= 2 * backgroundThickness;
      width -= 2 * backgroundThickness;
      // Top
      g.setColor(backgroundColor);
      g.drawLine(x, y, x + width, y);
      g.drawLine(x, y + 1, x + width, y + 1);
      g.drawLine(x, y + 2, x + width, y + 2);
      g.setColor(borderColor);
      g.drawLine(x, y + 3, x + width, y + 3);

      // Bottom
      g.setColor(borderColor);
      g.drawLine(x, y + height - 4, x + width, y + height - 4);
      g.setColor(shadowColor);
      g.drawLine(x, y + height - 3, x + width, y + height - 3);
      g.drawLine(x, y + height - 2, x + width, y + height - 2);

      // Left
      g.setColor(backgroundColor);
      g.drawLine(x, y, x, y + height);
      g.drawLine(x + 1, y, x + 1, y + height);
      g.drawLine(x + 2, y, x + 2, y + height);
      g.setColor(borderColor);
      g.drawLine(x + 3, y, x + 3, y + height);

      // Right
      g.setColor(borderColor);
      g.drawLine(x + width - 4, y, x + width - 4, y + height);
      g.setColor(shadowColor);
      g.drawLine(x + width - 3, y, x + width - 3, y + height);
      g.drawLine(x + width - 2, y, x + width - 2, y + height);

      // Background around the border
      g.setColor(backgroundColor);
      for (int i = 0; i < backgroundThickness + 1; i++) {
        g.drawRect(x - i, y - i, width - 1 + 2 * i, height - 1 + 2 * i);
      }

      // Corners
      height += backgroundThickness;
      width += backgroundThickness;
      topLeftCorner.paintIcon(c, g, x, y);
      topRightCorner.paintIcon(c, g, x + width - insets.right, y);
      bottomLeftCorner.paintIcon(c, g, x, y + height - insets.bottom);
      bottomRightCorner.paintIcon(c, g, x + width - insets.right, y + height - insets.bottom);
    }
  }

  /**
   * A border with rounded corners and a shadow *
   *
   * @author Poul Henriksen
   */
  private static class ShadowBorder extends AbstractBorder {
    private Insets insets;
    private Color shadowColor = new Color(145, 145, 145);
    private Color backgroundColor = Color.white;
    private Color borderColor = Color.black;
    private int backgroundThickness = 5; // extra space around the frame

    public ShadowBorder() {
      insets =
          new Insets(
              4 + backgroundThickness,
              4 + backgroundThickness,
              4 + backgroundThickness,
              4 + backgroundThickness);
    }

    /**
     * Reinitializes the insets parameter with this Border's current Insets.
     *
     * @param c the component for which this border insets value applies
     * @param insets the object to be reinitialized
     * @return the <code>insets</code> object
     */
    public Insets getBorderInsets(Component c, Insets insets) {
      insets.bottom = this.insets.bottom;
      insets.top = this.insets.top;
      insets.left = this.insets.left;
      insets.right = this.insets.right;
      return insets;
    }

    /**
     * Returns a new <code>Insets</code> instance.
     *
     * @param c the component for which this border insets value applies
     * @return the new <code>Insets</code> object
     */
    public Insets getBorderInsets(Component c) {
      return (Insets) insets.clone();
    }

    /** Returns false. */
    public boolean isBorderOpaque() {
      return false;
    }

    /** Paints the border */
    public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {

      x += backgroundThickness;
      y += backgroundThickness;
      height -= 2 * backgroundThickness;
      width -= 2 * backgroundThickness;

      // Right
      g.setColor(borderColor);
      g.drawLine(x + width - 4, y, x + width - 4, y + height);
      g.setColor(shadowColor);
      g.drawLine(x + width - 3, y, x + width - 3, y + height);
      g.drawLine(x + width - 2, y, x + width - 2, y + height);
      g.setColor(backgroundColor);
      g.drawLine(x + width - 1, y, x + width - 1, y + height);
      g.fillRect(x + width - 3, y, x + width, y + 5);

      // Bottom
      g.setColor(borderColor);
      g.drawLine(x + 3, y + height - 4, x + width - 4, y + height - 4);
      g.setColor(shadowColor);
      g.drawLine(x, y + height - 3, x + width - 2, y + height - 3);
      g.drawLine(x, y + height - 2, x + width - 2, y + height - 2);
      g.setColor(backgroundColor);
      g.drawLine(x, y + height - 1, x + width, y + height - 1);
      g.fillRect(x, y + height - 3, x + 5, y + height);

      // Top
      g.setColor(backgroundColor);
      g.drawLine(x, y, x + width, y);
      g.drawLine(x, y + 1, x + width, y + 1);
      g.drawLine(x, y + 2, x + width, y + 2);
      g.setColor(borderColor);
      g.drawLine(x, y + 3, x + width - 4, y + 3);

      // Left
      g.setColor(backgroundColor);
      g.drawLine(x, y, x, y + height);
      g.drawLine(x + 1, y, x + 1, y + height);
      g.drawLine(x + 2, y, x + 2, y + height);
      g.setColor(borderColor);
      g.drawLine(x + 3, y + 3, x + 3, y + height - 4);

      // Background around the border
      g.setColor(backgroundColor);
      for (int i = 0; i < backgroundThickness + 1; i++) {
        g.drawRect(x - i, y - i, width - 1 + 2 * i, height - 1 + 2 * i);
      }
    }
  }
}