/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */

/*

Part of the Processing project - http://processing.org

Copyright (c) 2012-15 The Processing Foundation

Copyright (c) 2004-12 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 version 2

as published by the Free Software Foundation.

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.ui;

import processing.app.Base;

import processing.app.Formatter;

import processing.app.Language;

import processing.app.Mode;

import processing.app.Preferences;

import processing.app.RunnerListener;

import processing.app.Sketch;

import processing.app.SketchCode;

import processing.app.SketchException;

import processing.app.contrib.ToolContribution;

import processing.app.syntax.*;

import processing.app.tools.*;

import processing.core.*;

import java.awt.BorderLayout;

import java.awt.Component;

import java.awt.Dimension;

import java.awt.EventQueue;

import java.awt.Frame;

import java.awt.Image;

import java.awt.Point;

import java.awt.datatransfer.*;

import java.awt.event.*;

import java.awt.print.*;

import java.io.*;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Stack;

import java.util.Timer;

import java.util.TimerTask;

import javax.swing.*;

import javax.swing.event.*;

import javax.swing.plaf.basic.*;

import javax.swing.text.*;

import javax.swing.undo.*;

/**

* Main editor panel for the Processing Development Environment.

*/

public abstract class Editor extends JFrame implements RunnerListener {

protected Base base;

protected EditorState state;

protected Mode mode;

static public final int LEFT_GUTTER = 44;

static public final int RIGHT_GUTTER = 20;

static public final int GUTTER_MARGIN = 3;

// Otherwise, if the window is resized with the message label

// set to blank, its preferredSize() will be fuckered

static protected final String EMPTY =

" " +

" " +

" ";

/**

* true if this file has not yet been given a name by the user

*/

// private boolean untitled;

private PageFormat pageFormat;

private PrinterJob printerJob;

// File and sketch menus for re-inserting items

private JMenu fileMenu;

// private JMenuItem saveMenuItem;

// private JMenuItem saveAsMenuItem;

private JMenu sketchMenu;

protected EditorHeader header;

protected EditorToolbar toolbar;

protected JEditTextArea textarea;

protected EditorStatus status;

protected JSplitPane splitPane;

protected EditorFooter footer;

protected EditorConsole console;

// protected EditorLineStatus lineStatus;

// currently opened program

protected Sketch sketch;

// runtime information and window placement

private Point sketchWindowLocation;

// undo fellers

private JMenuItem undoItem, redoItem;

protected UndoAction undoAction;

protected RedoAction redoAction;

protected CutAction cutAction;

protected CopyAction copyAction;

protected CopyAsHtmlAction copyAsHtmlAction;

protected PasteAction pasteAction;

/** Menu Actions updated on the opening of the edit menu. */

protected List<UpdatableAction> editMenuUpdatable = new ArrayList<UpdatableAction>();

/** The currently selected tab's undo manager */

private UndoManager undo;

// used internally for every edit. Groups hotkey-event text manipulations and

// groups multi-character inputs into a single undos.

private CompoundEdit compoundEdit;

// timer to decide when to group characters into an undo

private Timer timer;

private TimerTask endUndoEvent;

// true if inserting text, false if removing text

private boolean isInserting;

// maintain caret position during undo operations

private final Stack<Integer> caretUndoStack = new Stack<Integer>();

private final Stack<Integer> caretRedoStack = new Stack<Integer>();

private FindReplace find;

JMenu toolsMenu;

JMenu modeMenu;

List<ToolContribution> coreTools;

List<ToolContribution> contribTools;

Image backgroundGradient;

// protected Editor(final Base base, String path, int[] location, final Mode mode) {

protected Editor(final Base base, String path, EditorState state, final Mode mode) {

super("Processing", state.checkConfig());

this.base = base;

this.state = state;

this.mode = mode;

Toolkit.setIcon(this); // TODO should this be per-mode?

// Install default actions for Run, Present, etc.

// resetHandlers();

// add listener to handle window close box hit event

addWindowListener(new WindowAdapter() {

public void windowClosing(WindowEvent e) {

base.handleClose(Editor.this, false);

}

});

// don't close the window when clicked, the app will take care

// of that via the handleQuitInternal() methods

// http://dev.processing.org/bugs/show_bug.cgi?id=440

setDefaultCloseOperation(WindowConstants.DO_NOTHING_ON_CLOSE);

// When bringing a window to front, let the Base know

addWindowListener(new WindowAdapter() {

// int importIndex;

public void windowActivated(WindowEvent e) {

base.handleActivated(Editor.this);

fileMenu.insert(base.getRecentMenu(), 2);

Toolkit.setMenuMnemsInside(fileMenu);

//sketchMenu.insert(mode.getImportMenu(), 5);

mode.insertImportMenu(sketchMenu);

//sketchMenu.insert(mode.getImportMenu(), importIndex);

Toolkit.setMenuMnemsInside(sketchMenu);

mode.insertToolbarRecentMenu();

}

public void windowDeactivated(WindowEvent e) {

fileMenu.remove(base.getRecentMenu());

// JMenu importMenu = mode.getImportMenu();

// importIndex = sketchMenu.getComponentZOrder(mode.getImportMenu());

// sketchMenu.remove(mode.getImportMenu());

mode.removeImportMenu(sketchMenu);

mode.removeToolbarRecentMenu();

}

});

timer = new Timer();

buildMenuBar();

/*

//backgroundGradient = Toolkit.getLibImage("vertical-gradient.png");

backgroundGradient = mode.getGradient("editor", 400, 400);

JPanel contentPain = new JPanel() {

@Override

public void paintComponent(Graphics g) {

// super.paintComponent(g);

Dimension dim = getSize();

g.drawImage(backgroundGradient, 0, 0, dim.width, dim.height, this);

// g.setColor(Color.RED);

// g.fillRect(0, 0, dim.width, dim.height);

}

};

*/

//contentPain.setBorder(new EmptyBorder(0, 0, 0, 0));

//System.out.println(contentPain.getBorder());

JPanel contentPain = new JPanel();

// JFrame f = new JFrame();

// f.setContentPane(new JPanel() {

// @Override

// public void paintComponent(Graphics g) {

//// super.paintComponent(g);

// Dimension dim = getSize();

// g.drawImage(backgroundGradient, 0, 0, dim.width, dim.height, this);

//// g.setColor(Color.RED);

//// g.fillRect(0, 0, dim.width, dim.height);

// }

// });

// f.setResizable(true);

// f.setVisible(true);

//Container contentPain = getContentPane();

setContentPane(contentPain);

contentPain.setLayout(new BorderLayout());

// JPanel pain = new JPanel();

// pain.setOpaque(false);

// pain.setLayout(new BorderLayout());

// contentPain.add(pain, BorderLayout.CENTER);

// contentPain.setBorder(new EmptyBorder(10, 10, 10, 10));

Box box = Box.createVerticalBox();

Box upper = Box.createVerticalBox();

// upper.setOpaque(false);

// box.setOpaque(false);

initModeMenu();

toolbar = createToolbar();

upper.add(toolbar);

header = createHeader();

upper.add(header);

textarea = createTextArea();

textarea.setRightClickPopup(new TextAreaPopup());

textarea.setHorizontalOffset(JEditTextArea.leftHandGutter);

footer = createFooter();

upper.add(textarea);

// alternate spot for status, but ugly

// status = new EditorStatus(this);

// upper.add(status);

splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT, upper, footer);

// disable this because it hides the message area, which is essential (issue #745)

splitPane.setOneTouchExpandable(false);

// repaint child panes while resizing

splitPane.setContinuousLayout(true);

// if window increases in size, give all of increase to

// the textarea in the upper pane

splitPane.setResizeWeight(1D);

// remove any ugly borders added by PLAFs (doesn't fix everything)

splitPane.setBorder(null);

// remove an ugly border around anything in a SplitPane !$*&!%

UIManager.getDefaults().put("SplitPane.border", BorderFactory.createEmptyBorder());

// set the height per our gui design

//splitPane.setDividerSize(mode.getInteger("divider.height"));

splitPane.setDividerSize(EditorStatus.HIGH);

// override the look of the SplitPane so that it's identical across OSes

splitPane.setUI(new BasicSplitPaneUI() {

public BasicSplitPaneDivider createDefaultDivider() {

status = new EditorStatus(this, Editor.this);

return status;

/*

return new BasicSplitPaneDivider(this) {

final Color dividerColor = mode.getColor("divider.color"); //new Color(204, 204, 204);

final Color dotColor = mode.getColor("divider.dot.color"); //new Color(80, 80, 80);

int dotSize = mode.getInteger("divider.dot.diameter"); //3;

@Override

public void paint(Graphics g) {

Graphics2D g2 = (Graphics2D) g;

g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,

RenderingHints.VALUE_ANTIALIAS_ON);

final int w = getSize().width;

final int h = getSize().height;

g.setColor(dividerColor);

g.fillRect(0, 0, w, h);

g.setColor(dotColor);

int x = w/2 - dotSize/2;

int y = h/2 - dotSize/2;

g.fillOval(x, y, dotSize, dotSize);

}

};

*/

}

});

box.add(splitPane);

contentPain.add(box);

// get shift down/up events so we can show the alt version of toolbar buttons

//textarea.addKeyListener(toolbar);

// end an undo-chunk any time the caret moves unless it's when text is edited

textarea.addCaretListener(new CaretListener() {

String lastText = textarea.getText();

public void caretUpdate(CaretEvent e) {

String newText = textarea.getText();

if (lastText.equals(newText) && isDirectEdit()) {

endTextEditHistory();

}

lastText = newText;

}

});

contentPain.setTransferHandler(new FileDropHandler());

// Finish preparing Editor (formerly found in Base)

pack();

// Set the window bounds and the divider location before setting it visible

state.apply(this);

// Set the minimum size for the editor window

setMinimumSize(new Dimension(Preferences.getInteger("editor.window.width.min"),

Preferences.getInteger("editor.window.height.min")));

// Bring back the general options for the editor

applyPreferences();

// Make textField get the focus whenever frame is activated.

// http://download.oracle.com/javase/tutorial/uiswing/misc/focus.html

// May not be necessary, but helps avoid random situations with

// the editor not being able to request its own focus.

addWindowFocusListener(new WindowAdapter() {

public void windowGainedFocus(WindowEvent e) {

textarea.requestFocusInWindow();

}

// public void windowLostFocus(WindowEvent e) {

// System.out.println("lost focus, should we tell the text area?");

// }

});

// Open the document that was passed in

boolean loaded = handleOpenInternal(path);

if (!loaded) {

sketch = null;

}

// Add a window listener to watch for changes to the files in the sketch

addWindowFocusListener(new ChangeDetector(this));

}

protected List<ToolContribution> getCoreTools() {

return coreTools;

}

public List<ToolContribution> getToolContribs() {

return contribTools;

}

public void removeToolContrib(ToolContribution tc) {

contribTools.remove(tc);

}

/**

* Broken out to get modes working for GSOC, but this needs a longer-term

* solution where the listeners are handled properly.

*/

protected JEditTextArea createTextArea() {

return new JEditTextArea(new PdeTextAreaDefaults(mode),

new PdeInputHandler());

/*

return new JEditTextArea(new PdeTextAreaDefaults(mode), new PdeInputHandler()) {

// this is a kludge that needs to be removed [fry 150120]

public void processKeyEvent(KeyEvent evt) {

// this had to be added in Processing 007X, because the menu key

// events weren't making it up to the frame.

super.processKeyEvent(evt);

if (inputHandler != null) {

// Prevent sketch being marked modified cia ctrl-, on Windows/Linux

if ((evt.getModifiers() & InputEvent.CTRL_MASK) != 0 &&

evt.getKeyChar() == ',') {

System.out.println("skipping " + evt);

return;

}

switch (evt.getID()) {

case KeyEvent.KEY_TYPED:

inputHandler.keyTyped(evt);

break;

case KeyEvent.KEY_PRESSED:

inputHandler.keyPressed(evt);

break;

case KeyEvent.KEY_RELEASED:

inputHandler.keyReleased(evt);

break;

}

}

}

};

*/

}

public EditorFooter createFooter() {

EditorFooter ef = new EditorFooter(this);

console = new EditorConsole(this);

ef.addPanel(Language.text("editor.footer.console"), console);

return ef;

/*

// assemble console panel, consisting of status area and the console itself

JPanel panel = new JPanel();

panel.setLayout(new BorderLayout());

// status = new EditorStatus(this);

// consolePanel.add(status, BorderLayout.NORTH);

console = new EditorConsole(this);

// windows puts an ugly border on this guy

console.setBorder(null);

panel.add(console, BorderLayout.CENTER);

// lineStatus = new EditorLineStatus(this);

// consolePanel.add(lineStatus, BorderLayout.SOUTH);

return panel;

*/

}

public EditorState getEditorState() {

return state;

}

public void removeRecent() {

base.removeRecent(this);

}

public void addRecent() {

base.handleRecent(this);

}

/**

* Handles files dragged & dropped from the desktop and into the editor

* window. Dragging files into the editor window is the same as using

* "Sketch &rarr; Add File" for each file.

*/

class FileDropHandler extends TransferHandler {

public boolean canImport(TransferHandler.TransferSupport support) {

return !sketch.isReadOnly();

}

@SuppressWarnings("unchecked")

public boolean importData(TransferHandler.TransferSupport support) {

int successful = 0;

if (!canImport(support)) {

return false;

}

try {

Transferable transferable = support.getTransferable();

DataFlavor uriListFlavor =

new DataFlavor("text/uri-list;class=java.lang.String");

if (transferable.isDataFlavorSupported(DataFlavor.javaFileListFlavor)) {

List list = (List)

transferable.getTransferData(DataFlavor.javaFileListFlavor);

for (int i = 0; i < list.size(); i++) {

File file = (File) list.get(i);

if (sketch.addFile(file)) {

successful++;

}

}

} else if (transferable.isDataFlavorSupported(uriListFlavor)) {

// Some platforms (Mac OS X and Linux, when this began) preferred

// this method of moving files.

String data = (String)transferable.getTransferData(uriListFlavor);

String[] pieces = PApplet.splitTokens(data, "\r\n");

for (int i = 0; i < pieces.length; i++) {

if (pieces[i].startsWith("#")) continue;

String path = null;

if (pieces[i].startsWith("file:///")) {

path = pieces[i].substring(7);

} else if (pieces[i].startsWith("file:/")) {

path = pieces[i].substring(5);

}

if (sketch.addFile(new File(path))) {

successful++;

}

}

}

} catch (Exception e) {

Base.showWarning("Drag & Drop Problem",

"An error occurred while trying to add files to the sketch.", e);

return false;

}

statusNotice(Language.pluralize("editor.status.drag_and_drop.files_added", successful));

return true;

}

}

public Base getBase() {

return base;

}

public Mode getMode() {

return mode;

}

public void repaintHeader() {

header.repaint();

}

public void rebuildHeader() {

header.rebuild();

}

protected void initModeMenu() {

modeMenu = new JMenu();

ButtonGroup modeGroup = new ButtonGroup();

for (final Mode m : base.getModeList()) {

JRadioButtonMenuItem item = new JRadioButtonMenuItem(m.getTitle());

item.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (!sketch.isModified()) {

base.changeMode(m);

} else {

Base.showWarning("Save",

"Please save the sketch before changing the mode.",

null);

// Re-select the old checkbox, because it was automatically

// updated by Java, even though the Mode could not be changed.

// https://github.com/processing/processing/issues/2615

for (Component c : modeMenu.getPopupMenu().getComponents()) {

if (c instanceof JRadioButtonMenuItem) {

if (((JRadioButtonMenuItem)c).getText() == mode.getTitle()) {

((JRadioButtonMenuItem)c).setSelected(true);

break;

}

}

}

}

}

});

modeMenu.add(item);

modeGroup.add(item);

if (mode == m) {

item.setSelected(true);

}

}

modeMenu.addSeparator();

JMenuItem addLib = new JMenuItem(Language.text("toolbar.add_mode"));

addLib.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

base.handleOpenModeManager();

}

});

modeMenu.add(addLib);

Toolkit.setMenuMnemsInside(modeMenu);

}

public void rebuildModeMenu() {

initModeMenu();

}

public JMenu getModeMenu() {

return modeMenu;

}

public EditorConsole getConsole() {

return console;

}

// public Settings getTheme() {

// return mode.getTheme();

// }

public EditorHeader createHeader() {

return new EditorHeader(this);

}

abstract public EditorToolbar createToolbar();

public void rebuildToolbar() {

toolbar.rebuild();

toolbar.revalidate(); // necessary to handle sub-components

}

abstract public Formatter createFormatter();

// protected void setPlacement(int[] location) {

// setBounds(location[0], location[1], location[2], location[3]);

// if (location[4] != 0) {

// splitPane.setDividerLocation(location[4]);

// }

// }

//

//

// protected int[] getPlacement() {

// int[] location = new int[5];

//

// // Get the dimensions of the Frame

// Rectangle bounds = getBounds();

// location[0] = bounds.x;

// location[1] = bounds.y;

// location[2] = bounds.width;

// location[3] = bounds.height;

//

// // Get the current placement of the divider

// location[4] = splitPane.getDividerLocation();

//

// return location;

// }

protected void setDividerLocation(int pos) {

splitPane.setDividerLocation(pos);

}

protected int getDividerLocation() {

return splitPane.getDividerLocation();

}

// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/**

* Read and apply new values from the preferences, either because

* the app is just starting up, or the user just finished messing

* with things in the Preferences window.

*/

protected void applyPreferences() {

// Update fonts and other items controllable from the prefs

textarea.getPainter().updateAppearance();

textarea.repaint();

console.updateAppearance();

// All of this code was specific to using an external editor.

/*

// // apply the setting for 'use external editor'

// boolean external = Preferences.getBoolean("editor.external");

// textarea.setEditable(!external);

// saveMenuItem.setEnabled(!external);

// saveAsMenuItem.setEnabled(!external);

TextAreaPainter painter = textarea.getPainter();

// if (external) {

// // disable line highlight and turn off the caret when disabling

// Color color = mode.getColor("editor.external.bgcolor");

// painter.setBackground(color);

// painter.setLineHighlightEnabled(false);

// textarea.setCaretVisible(false);

// } else {

Color color = mode.getColor("editor.bgcolor");

painter.setBackground(color);

boolean highlight = Preferences.getBoolean("editor.linehighlight");

painter.setLineHighlightEnabled(highlight);

textarea.setCaretVisible(true);

// }

// apply changes to the font size for the editor

// painter.setFont(Preferences.getFont("editor.font"));

// in case tab expansion stuff has changed

// removing this, just checking prefs directly instead

// listener.applyPreferences();

// in case moved to a new location

// For 0125, changing to async version (to be implemented later)

//sketchbook.rebuildMenus();

// For 0126, moved into Base, which will notify all editors.

//base.rebuildMenusAsync();

*/

}

// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

protected void buildMenuBar() {

JMenuBar menubar = new JMenuBar();

fileMenu = buildFileMenu();

menubar.add(fileMenu);

menubar.add(buildEditMenu());

menubar.add(buildSketchMenu());

// For 3.0a4 move mode menu to the left of the Tool menu

JMenu modeMenu = buildModeMenu();

if (modeMenu != null) {

menubar.add(modeMenu);

}

rebuildToolMenu();

menubar.add(getToolMenu());

menubar.add(buildHelpMenu());

Toolkit.setMenuMnemonics(menubar);

setJMenuBar(menubar);

}

abstract public JMenu buildFileMenu();

// public JMenu buildFileMenu(Editor editor) {

// return buildFileMenu(editor, null);

// }

//

//

// // most of these items are per-mode

// protected JMenu buildFileMenu(Editor editor, JMenuItem[] exportItems) {

protected JMenu buildFileMenu(JMenuItem[] exportItems) {

JMenuItem item;

JMenu fileMenu = new JMenu(Language.text("menu.file"));

item = Toolkit.newJMenuItem(Language.text("menu.file.new"), 'N');

item.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

base.handleNew();

}

});

fileMenu.add(item);

item = Toolkit.newJMenuItem(Language.text("menu.file.open"), 'O');

item.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

base.handleOpenPrompt();

}

});

fileMenu.add(item);

// fileMenu.add(base.getSketchbookMenu());

item = Toolkit.newJMenuItemShift(Language.text("menu.file.sketchbook"), 'K');

item.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

mode.showSketchbookFrame();

}

});

fileMenu.add(item);

item = Toolkit.newJMenuItemShift(Language.text("menu.file.examples"), 'O');

item.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

mode.showExamplesFrame();

}

});

fileMenu.add(item);

item = Toolkit.newJMenuItem(Language.text("menu.file.close"), 'W');

item.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

base.handleClose(Editor.this, false);

}

});

fileMenu.add(item);

item = Toolkit.newJMenuItem(Language.text("menu.file.save"), 'S');

item.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

handleSave(false);

}

});

// saveMenuItem = item;

fileMenu.add(item);

item = Toolkit.newJMenuItemShift(Language.text("menu.file.save_as"), 'S');

item.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

handleSaveAs();

}

});

// saveAsMenuItem = item;

fileMenu.add(item);

if (exportItems != null) {

for (JMenuItem ei : exportItems) {

fileMenu.add(ei);

}

}

fileMenu.addSeparator();

item = Toolkit.newJMenuItemShift(Language.text("menu.file.page_setup"), 'P');

item.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

handlePageSetup();

}

});

fileMenu.add(item);

item = Toolkit.newJMenuItem(Language.text("menu.file.print"), 'P');

item.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

handlePrint();

}

});

fileMenu.add(item);

// Mac OS X already has its own preferences and quit menu.

// That's right! Think different, b*tches!

if (!Base.isMacOS()) {

fileMenu.addSeparator();

item = Toolkit.newJMenuItem(Language.text("menu.file.preferences"), ',');

item.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

base.handlePrefs();

}

});

fileMenu.add(item);

fileMenu.addSeparator();

item = Toolkit.newJMenuItem(Language.text("menu.file.quit"), 'Q');

item.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

base.handleQuit();

}

});

fileMenu.add(item);

}

return fileMenu;

}

// public void setSaveItem(JMenuItem item) {

// saveMenuItem = item;

// }

// public void setSaveAsItem(JMenuItem item) {

// saveAsMenuItem = item;

// }

protected JMenu buildEditMenu() {

JMenu menu = new JMenu(Language.text("menu.edit"));

JMenuItem item;

undoItem = Toolkit.newJMenuItem(undoAction = new UndoAction(), 'Z');

menu.add(undoItem);

// Gotta follow them interface guidelines

// http://code.google.com/p/processing/issues/detail?id=363

if (Base.isWindows()) {

redoItem = Toolkit.newJMenuItem(redoAction = new RedoAction(), 'Y');

} else { // Linux and OS X

redoItem = Toolkit.newJMenuItemShift(redoAction = new RedoAction(), 'Z');

}

menu.add(redoItem);

menu.addSeparator();

item = Toolkit.newJMenuItem(cutAction = new CutAction(), 'X');

editMenuUpdatable.add(cutAction);

menu.add(item);

item = Toolkit.newJMenuItem(copyAction = new CopyAction(), 'C');

editMenuUpdatable.add(copyAction);

menu.add(item);

item = Toolkit.newJMenuItemShift(copyAsHtmlAction = new CopyAsHtmlAction(), 'C');

editMenuUpdatable.add(copyAsHtmlAction);

menu.add(item);

item = Toolkit.newJMenuItem(pasteAction = new PasteAction(), 'V');

editMenuUpdatable.add(pasteAction);

menu.add(item);

item = Toolkit.newJMenuItem(Language.text("menu.edit.select_all"), 'A');

item.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

textarea.selectAll();

}

});

menu.add(item);

/*

menu.addSeparator();

item = Toolkit.newJMenuItem("Delete Selected Lines", 'D');

item.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

handleDeleteLines();

}

});

menu.add(item);

item = new JMenuItem("Move Selected Lines Up");

item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_UP, Event.ALT_MASK));

item.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

handleMoveLines(true);

}

});

menu.add(item);

item = new JMenuItem("Move Selected Lines Down");

item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, Event.ALT_MASK));

item.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

handleMoveLines(false);

}

});

menu.add(item);

*/

menu.addSeparator();

item = Toolkit.newJMenuItem(Language.text("menu.edit.auto_format"), 'T');

item.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

handleAutoFormat();

}

});

menu.add(item);

item = Toolkit.newJMenuItem(Language.text("menu.edit.comment_uncomment"), '/');

item.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

handleCommentUncomment();

}

});

menu.add(item);

item = Toolkit.newJMenuItem("\u2192 "+Language.text("menu.edit.increase_indent"), ']');

item.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

handleIndentOutdent(true);

}

});

menu.add(item);

item = Toolkit.newJMenuItem("\u2190 "+Language.text("menu.edit.decrease_indent"), '[');

item.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

handleIndentOutdent(false);

}

});

menu.add(item);

menu.addSeparator();