/**

     * whether parsing should be strict (throw exception on error) or not

     */

    boolean strictParsing = false;

import org.apache.batik.swing.JSVGCanvas;

import org.apache.batik.util.gui.ErrorConsole;

import org.apache.batik.util.gui.ErrorConsole;

import java.lang.reflect.Proxy;

import org.apache.batik.swing.svg.SVGDocumentLoader;

import org.apache.batik.util.gui.ErrorHandlerProxy;

//		System.out.println("Installing proxy");

//		SVGDocumentFactory documentFactoryProxy = (SVGDocumentFactory) Proxy

//				.newProxyInstance(SVGDocumentFactory.class

//						.getClassLoader(),

//						new Class[] { SVGDocumentFactory.class },

//						new ErrorHandlerProxy(documentFactory, uri));

//        SVGDocument document = documentFactoryProxy.createSVGDocument(uri);

import javax.swing.JOptionPane;

import org.apache.batik.util.gui.ErrorConsole;

/*

 * TextAreaPainter.java - Paints the text area

 * Copyright (C) 1999 Slava Pestov

 *

 * You may use and modify this package for any purpose. Redistribution is

 * permitted, in both source and binary form, provided that this notice

 * remains intact in all source distributions of this package.

 */

package org.apache.batik.apps.svgbrowser.srcview;

import javax.swing.ToolTipManager;

import javax.swing.text.*;

import javax.swing.JComponent;

import java.awt.event.MouseEvent;

import java.awt.*;

/**

 * The text area repaint manager. It performs double buffering and paints

 * lines of text.

 * @author Slava Pestov

 * @version $Id: TextAreaPainter.java,v 1.24 1999/12/13 03:40:30 sp Exp $

 */

public class TextAreaPainter extends JComponent implements TabExpander

{

	/**

	 * Creates a new repaint manager. This should be not be called

	 * directly.

	 */

	public TextAreaPainter(JEditTextArea textArea, TextAreaDefaults defaults)

	{

		this.textArea = textArea;

		setAutoscrolls(true);

		setDoubleBuffered(true);

		setOpaque(true);

		ToolTipManager.sharedInstance().registerComponent(this);

		currentLine = new Segment();

		currentLineIndex = -1;

		setCursor(Cursor.getPredefinedCursor(Cursor.TEXT_CURSOR));

		setFont(new Font("Monospaced",Font.PLAIN,14));

		setForeground(Color.black);

		setBackground(Color.white);

		blockCaret = defaults.blockCaret;

		styles = defaults.styles;

		cols = defaults.cols;

		rows = defaults.rows;

		caretColor = defaults.caretColor;

		selectionColor = defaults.selectionColor;

		lineHighlightColor = defaults.lineHighlightColor;

		lineHighlight = defaults.lineHighlight;

		bracketHighlightColor = defaults.bracketHighlightColor;

		bracketHighlight = defaults.bracketHighlight;

		paintInvalid = defaults.paintInvalid;

		eolMarkerColor = defaults.eolMarkerColor;

		eolMarkers = defaults.eolMarkers;

	}

	/**

	 * Returns if this component can be traversed by pressing the

	 * Tab key. This returns false.

	 */

	public final boolean isManagingFocus()

	{

		return false;

	}

	/**

	 * Returns the syntax styles used to paint colorized text. Entry <i>n</i>

	 * will be used to paint tokens with id = <i>n</i>.

	 * @see org.gjt.sp.jedit.syntax.Token

	 */

	public final SyntaxStyle[] getStyles()

	{

		return styles;

	}

	/**

	 * Sets the syntax styles used to paint colorized text. Entry <i>n</i>

	 * will be used to paint tokens with id = <i>n</i>.

	 * @param styles The syntax styles

	 * @see org.gjt.sp.jedit.syntax.Token

	 */

	public final void setStyles(SyntaxStyle[] styles)

	{

		this.styles = styles;

		repaint();

	}

	/**

	 * Returns the caret color.

	 */

	public final Color getCaretColor()

	{

		return caretColor;

	}

	/**

	 * Sets the caret color.

	 * @param caretColor The caret color

	 */

	public final void setCaretColor(Color caretColor)

	{

		this.caretColor = caretColor;

		invalidateSelectedLines();

	}

	/**

	 * Returns the selection color.

	 */

	public final Color getSelectionColor()

	{

		return selectionColor;

	}

	/**

	 * Sets the selection color.

	 * @param selectionColor The selection color

	 */

	public final void setSelectionColor(Color selectionColor)

	{

		this.selectionColor = selectionColor;

		invalidateSelectedLines();

	}

	/**

	 * Returns the line highlight color.

	 */

	public final Color getLineHighlightColor()

	{

		return lineHighlightColor;

	}

	/**

	 * Sets the line highlight color.

	 * @param lineHighlightColor The line highlight color

	 */

	public final void setLineHighlightColor(Color lineHighlightColor)

	{

		this.lineHighlightColor = lineHighlightColor;

		invalidateSelectedLines();

	}

	/**

	 * Returns true if line highlight is enabled, false otherwise.

	 */

	public final boolean isLineHighlightEnabled()

	{

		return lineHighlight;

	}

	/**

	 * Enables or disables current line highlighting.

	 * @param lineHighlight True if current line highlight should be enabled,

	 * false otherwise

	 */

	public final void setLineHighlightEnabled(boolean lineHighlight)

	{

		this.lineHighlight = lineHighlight;

		invalidateSelectedLines();

	}

	/**

	 * Returns the bracket highlight color.

	 */

	public final Color getBracketHighlightColor()

	{

		return bracketHighlightColor;

	}

	/**

	 * Sets the bracket highlight color.

	 * @param bracketHighlightColor The bracket highlight color

	 */

	public final void setBracketHighlightColor(Color bracketHighlightColor)

	{

		this.bracketHighlightColor = bracketHighlightColor;

		invalidateLine(textArea.getBracketLine());

	}

	/**

	 * Returns true if bracket highlighting is enabled, false otherwise.

	 * When bracket highlighting is enabled, the bracket matching the

	 * one before the caret (if any) is highlighted.

	 */

	public final boolean isBracketHighlightEnabled()

	{

		return bracketHighlight;

	}

	/**

	 * Enables or disables bracket highlighting.

	 * When bracket highlighting is enabled, the bracket matching the

	 * one before the caret (if any) is highlighted.

	 * @param bracketHighlight True if bracket highlighting should be

	 * enabled, false otherwise

	 */

	public final void setBracketHighlightEnabled(boolean bracketHighlight)

	{

		this.bracketHighlight = bracketHighlight;

		invalidateLine(textArea.getBracketLine());

	}

	/**

	 * Returns true if the caret should be drawn as a block, false otherwise.

	 */

	public final boolean isBlockCaretEnabled()

	{

		return blockCaret;

	}

	/**

	 * Sets if the caret should be drawn as a block, false otherwise.

	 * @param blockCaret True if the caret should be drawn as a block,

	 * false otherwise.

	 */

	public final void setBlockCaretEnabled(boolean blockCaret)

	{

		this.blockCaret = blockCaret;

		invalidateSelectedLines();

	}

	/**

	 * Returns the EOL marker color.

	 */

	public final Color getEOLMarkerColor()

	{

		return eolMarkerColor;

	}

	/**

	 * Sets the EOL marker color.

	 * @param eolMarkerColor The EOL marker color

	 */

	public final void setEOLMarkerColor(Color eolMarkerColor)

	{

		this.eolMarkerColor = eolMarkerColor;

		repaint();

	}

	/**

	 * Returns true if EOL markers are drawn, false otherwise.

	 */

	public final boolean getEOLMarkersPainted()

	{

		return eolMarkers;

	}

	/**

	 * Sets if EOL markers are to be drawn.

	 * @param eolMarkers True if EOL markers should be drawn, false otherwise

	 */

	public final void setEOLMarkersPainted(boolean eolMarkers)

	{

		this.eolMarkers = eolMarkers;

		repaint();

	}

	/**

	 * Returns true if invalid lines are painted as red tildes (~),

	 * false otherwise.

	 */

	public boolean getInvalidLinesPainted()

	{

		return paintInvalid;

	}

	/**

	 * Sets if invalid lines are to be painted as red tildes.

	 * @param paintInvalid True if invalid lines should be drawn, false otherwise

	 */

	public void setInvalidLinesPainted(boolean paintInvalid)

	{

		this.paintInvalid = paintInvalid;

	}

	/**

	 * Adds a custom highlight painter.

	 * @param highlight The highlight

	 */

	public void addCustomHighlight(Highlight highlight)

	{

		highlight.init(textArea,highlights);

		highlights = highlight;

	}

	/**

	 * Highlight interface.

	 */

	public interface Highlight

	{

		/**

		 * Called after the highlight painter has been added.

		 * @param textArea The text area

		 * @param next The painter this one should delegate to

		 */

		void init(JEditTextArea textArea, Highlight next);

		/**

		 * This should paint the highlight and delgate to the

		 * next highlight painter.

		 * @param gfx The graphics context

		 * @param line The line number

		 * @param y The y co-ordinate of the line

		 */

		void paintHighlight(Graphics gfx, int line, int y);

		/**

		 * Returns the tool tip to display at the specified

		 * location. If this highlighter doesn't know what to

		 * display, it should delegate to the next highlight

		 * painter.

		 * @param evt The mouse event

		 */

		String getToolTipText(MouseEvent evt);

	}

	/**

	 * Returns the tool tip to display at the specified location.

	 * @param evt The mouse event

	 */

	public String getToolTipText(MouseEvent evt)

	{

		if(highlights != null)

			return highlights.getToolTipText(evt);

		else

			return null;

	}

	/**

	 * Returns the font metrics used by this component.

	 */

	public FontMetrics getFontMetrics()

	{

		return fm;

	}

	/**

	 * Sets the font for this component. This is overridden to update the

	 * cached font metrics and to recalculate which lines are visible.

	 * @param font The font

	 */

	public void setFont(Font font)

	{

		super.setFont(font);

		fm = Toolkit.getDefaultToolkit().getFontMetrics(font);

		textArea.recalculateVisibleLines();

	}

	/**

	 * Repaints the text.

	 * @param g The graphics context

	 */

	public void paint(Graphics gfx)

	{

		tabSize = fm.charWidth(' ') * ((Integer)textArea

			.getDocument().getProperty(

			PlainDocument.tabSizeAttribute)).intValue();

		Rectangle clipRect = gfx.getClipBounds();

		gfx.setColor(getBackground());

		gfx.fillRect(clipRect.x,clipRect.y,clipRect.width,clipRect.height);

		// We don't use yToLine() here because that method doesn't

		// return lines past the end of the document

		int height = fm.getHeight();

		int firstLine = textArea.getFirstLine();

		int firstInvalid = firstLine + clipRect.y / height;

		// Because the clipRect's height is usually an even multiple

		// of the font height, we subtract 1 from it, otherwise one

		// too many lines will always be painted.

		int lastInvalid = firstLine + (clipRect.y + clipRect.height - 1) / height;

		try

		{

			TokenMarker tokenMarker = textArea.getDocument()

				.getTokenMarker();

			int x = textArea.getHorizontalOffset();

			for(int line = firstInvalid; line <= lastInvalid; line++)

			{

				paintLine(gfx,tokenMarker,line,x);

			}

			if(tokenMarker != null && tokenMarker.isNextLineRequested())

			{

				int h = clipRect.y + clipRect.height;

				repaint(0,h,getWidth(),getHeight() - h);

			}

		}

		catch(Exception e)

		{

			System.err.println("Error repainting line"

				+ " range {" + firstInvalid + ","

				+ lastInvalid + "}:");

			e.printStackTrace();

		}

	}

	/**

	 * Marks a line as needing a repaint.

	 * @param line The line to invalidate

	 */

	public final void invalidateLine(int line)

	{

		repaint(0,textArea.lineToY(line) + fm.getMaxDescent() + fm.getLeading(),

			getWidth(),fm.getHeight());

	}

	/**

	 * Marks a range of lines as needing a repaint.

	 * @param firstLine The first line to invalidate

	 * @param lastLine The last line to invalidate

	 */

	public final void invalidateLineRange(int firstLine, int lastLine)

	{

		repaint(0,textArea.lineToY(firstLine) + fm.getMaxDescent() + fm.getLeading(),

			getWidth(),(lastLine - firstLine + 1) * fm.getHeight());

	}

	/**

	 * Repaints the lines containing the selection.

	 */

	public final void invalidateSelectedLines()

	{

		invalidateLineRange(textArea.getSelectionStartLine(),

			textArea.getSelectionEndLine());

	}

	/**

	 * Implementation of TabExpander interface. Returns next tab stop after

	 * a specified point.

	 * @param x The x co-ordinate

	 * @param tabOffset Ignored

	 * @return The next tab stop after <i>x</i>

	 */

	public float nextTabStop(float x, int tabOffset)

	{

		int offset = textArea.getHorizontalOffset();

		int ntabs = ((int)x - offset) / tabSize;

		return (ntabs + 1) * tabSize + offset;

	}

	/**

	 * Returns the painter's preferred size.

	 */

	public Dimension getPreferredSize()

	{

		Dimension dim = new Dimension();

		dim.width = fm.charWidth('w') * cols;

		dim.height = fm.getHeight() * rows;

		return dim;

	}

	/**

	 * Returns the painter's minimum size.

	 */

	public Dimension getMinimumSize()

	{

		return getPreferredSize();

	}

	// package-private members

	int currentLineIndex;

	Token currentLineTokens;

	Segment currentLine;

	// protected members

	protected JEditTextArea textArea;

	protected SyntaxStyle[] styles;

	protected Color caretColor;

	protected Color selectionColor;

	protected Color lineHighlightColor;

	protected Color bracketHighlightColor;

	protected Color eolMarkerColor;

	protected boolean blockCaret;

	protected boolean lineHighlight;

	protected boolean bracketHighlight;

	protected boolean paintInvalid;

	protected boolean eolMarkers;

	protected int cols;

	protected int rows;

	protected int tabSize;

	protected FontMetrics fm;

	protected Highlight highlights;

	protected void paintLine(Graphics gfx, TokenMarker tokenMarker,

		int line, int x)

	{

		Font defaultFont = getFont();

		Color defaultColor = getForeground();

		currentLineIndex = line;

		int y = textArea.lineToY(line);

		if(line < 0 || line >= textArea.getLineCount())

		{

			if(paintInvalid)

			{

				paintHighlight(gfx,line,y);

				styles[Token.INVALID].setGraphicsFlags(gfx,defaultFont);

				gfx.drawString("~",0,y + fm.getHeight());

			}

		}

		else if(tokenMarker == null)

		{

			paintPlainLine(gfx,line,defaultFont,defaultColor,x,y);

		}

		else

		{

			paintSyntaxLine(gfx,tokenMarker,line,defaultFont,

				defaultColor,x,y);

		}

	}

	protected void paintPlainLine(Graphics gfx, int line, Font defaultFont,

		Color defaultColor, int x, int y)

	{

		paintHighlight(gfx,line,y);

		textArea.getLineText(line,currentLine);

		gfx.setFont(defaultFont);

		gfx.setColor(defaultColor);

		y += fm.getHeight();

		x = Utilities.drawTabbedText(currentLine,x,y,gfx,this,0);

		if(eolMarkers)

		{

			gfx.setColor(eolMarkerColor);

			gfx.drawString(".",x,y);

		}

	}

	protected void paintSyntaxLine(Graphics gfx, TokenMarker tokenMarker,

		int line, Font defaultFont, Color defaultColor, int x, int y)

	{

		textArea.getLineText(currentLineIndex,currentLine);

		currentLineTokens = tokenMarker.markTokens(currentLine,

			currentLineIndex);

		paintHighlight(gfx,line,y);

		gfx.setFont(defaultFont);

		gfx.setColor(defaultColor);

		y += fm.getHeight();

		x = SyntaxUtilities.paintSyntaxLine(currentLine,

			currentLineTokens,styles,this,gfx,x,y);

		if(eolMarkers)

		{

			gfx.setColor(eolMarkerColor);

			gfx.drawString(".",x,y);

		}

	}

	protected void paintHighlight(Graphics gfx, int line, int y)

	{

		if(line >= textArea.getSelectionStartLine()

			&& line <= textArea.getSelectionEndLine())

			paintLineHighlight(gfx,line,y);

		if(highlights != null)

			highlights.paintHighlight(gfx,line,y);

		if(bracketHighlight && line == textArea.getBracketLine())

			paintBracketHighlight(gfx,line,y);

		if(line == textArea.getCaretLine())

			paintCaret(gfx,line,y);

	}

	protected void paintLineHighlight(Graphics gfx, int line, int y)

	{

		int height = fm.getHeight();

		y += fm.getLeading() + fm.getMaxDescent();

		int selectionStart = textArea.getSelectionStart();

		int selectionEnd = textArea.getSelectionEnd();

		if(selectionStart == selectionEnd)

		{

			if(lineHighlight)

			{

				gfx.setColor(lineHighlightColor);

				gfx.fillRect(0,y,getWidth(),height);

			}

		}

		else

		{

			gfx.setColor(selectionColor);

			int selectionStartLine = textArea.getSelectionStartLine();

			int selectionEndLine = textArea.getSelectionEndLine();

			int lineStart = textArea.getLineStartOffset(line);

			int x1, x2;

			if(textArea.isSelectionRectangular())

			{

				int lineLen = textArea.getLineLength(line);

				x1 = textArea._offsetToX(line,Math.min(lineLen,

					selectionStart - textArea.getLineStartOffset(

					selectionStartLine)));

				x2 = textArea._offsetToX(line,Math.min(lineLen,

					selectionEnd - textArea.getLineStartOffset(

					selectionEndLine)));

				if(x1 == x2)

					x2++;

			}

			else if(selectionStartLine == selectionEndLine)

			{

				x1 = textArea._offsetToX(line,

					selectionStart - lineStart);

				x2 = textArea._offsetToX(line,

					selectionEnd - lineStart);

			}

			else if(line == selectionStartLine)

			{

				x1 = textArea._offsetToX(line,

					selectionStart - lineStart);

				x2 = getWidth();

			}

			else if(line == selectionEndLine)

			{

				x1 = 0;

				x2 = textArea._offsetToX(line,

					selectionEnd - lineStart);

			}

			else

			{

				x1 = 0;

				x2 = getWidth();

			}

			// "inlined" min/max()

			gfx.fillRect(x1 > x2 ? x2 : x1,y,x1 > x2 ?

				(x1 - x2) : (x2 - x1),height);

		}

	}

	protected void paintBracketHighlight(Graphics gfx, int line, int y)

	{

		int position = textArea.getBracketPosition();

		if(position == -1)

			return;

		y += fm.getLeading() + fm.getMaxDescent();

		int x = textArea._offsetToX(line,position);

		gfx.setColor(bracketHighlightColor);

		// Hack!!! Since there is no fast way to get the character

		// from the bracket matching routine, we use ( since all

		// brackets probably have the same width anyway

		gfx.drawRect(x,y,fm.charWidth('(') - 1,

			fm.getHeight() - 1);

	}

	protected void paintCaret(Graphics gfx, int line, int y)

	{

		if(textArea.isCaretVisible())

		{

			int offset = textArea.getCaretPosition() 

				- textArea.getLineStartOffset(line);

			int caretX = textArea._offsetToX(line,offset);

			int caretWidth = ((blockCaret ||

				textArea.isOverwriteEnabled()) ?

				fm.charWidth('w') : 1);

			y += fm.getLeading() + fm.getMaxDescent();

			int height = fm.getHeight();

			gfx.setColor(caretColor);

			if(textArea.isOverwriteEnabled())

			{

				gfx.fillRect(caretX,y + height - 1,

					caretWidth,1);

			}

			else

			{

				gfx.drawRect(caretX,y,caretWidth - 1,height - 1);

			}

		}

	}

}

/*

 * DefaultInputHandler.java - Default implementation of an input handler

 * Copyright (C) 1999 Slava Pestov

 *

 * You may use and modify this package for any purpose. Redistribution is

 * permitted, in both source and binary form, provided that this notice

 * remains intact in all source distributions of this package.

 */

package org.apache.batik.apps.svgbrowser.srcview;

import javax.swing.KeyStroke;

import java.awt.event.*;

import java.awt.Toolkit;

import java.util.Hashtable;

import java.util.StringTokenizer;

/**

 * The default input handler. It maps sequences of keystrokes into actions

 * and inserts key typed events into the text area.

 * @author Slava Pestov

 * @version $Id: DefaultInputHandler.java,v 1.18 1999/12/13 03:40:30 sp Exp $

 */

public class DefaultInputHandler extends InputHandler

{

	/**

	 * Creates a new input handler with no key bindings defined.

	 */

	public DefaultInputHandler()

	{

		bindings = currentBindings = new Hashtable();

	}

	/**

	 * Sets up the default key bindings.

	 */

	public void addDefaultKeyBindings()

	{

		addKeyBinding("BACK_SPACE",BACKSPACE);

		addKeyBinding("C+BACK_SPACE",BACKSPACE_WORD);

		addKeyBinding("DELETE",DELETE);

		addKeyBinding("C+DELETE",DELETE_WORD);

		addKeyBinding("ENTER",INSERT_BREAK);

		addKeyBinding("TAB",INSERT_TAB);

		addKeyBinding("INSERT",OVERWRITE);

		addKeyBinding("C+\\",TOGGLE_RECT);

		addKeyBinding("HOME",HOME);

		addKeyBinding("END",END);

		addKeyBinding("S+HOME",SELECT_HOME);

		addKeyBinding("S+END",SELECT_END);

		addKeyBinding("C+HOME",DOCUMENT_HOME);

		addKeyBinding("C+END",DOCUMENT_END);

		addKeyBinding("CS+HOME",SELECT_DOC_HOME);

		addKeyBinding("CS+END",SELECT_DOC_END);

		addKeyBinding("PAGE_UP",PREV_PAGE);

		addKeyBinding("PAGE_DOWN",NEXT_PAGE);

		addKeyBinding("S+PAGE_UP",SELECT_PREV_PAGE);

		addKeyBinding("S+PAGE_DOWN",SELECT_NEXT_PAGE);

		addKeyBinding("LEFT",PREV_CHAR);

		addKeyBinding("S+LEFT",SELECT_PREV_CHAR);

		addKeyBinding("C+LEFT",PREV_WORD);

		addKeyBinding("CS+LEFT",SELECT_PREV_WORD);

		addKeyBinding("RIGHT",NEXT_CHAR);

		addKeyBinding("S+RIGHT",SELECT_NEXT_CHAR);

		addKeyBinding("C+RIGHT",NEXT_WORD);

		addKeyBinding("CS+RIGHT",SELECT_NEXT_WORD);

		addKeyBinding("UP",PREV_LINE);

		addKeyBinding("S+UP",SELECT_PREV_LINE);

		addKeyBinding("DOWN",NEXT_LINE);

		addKeyBinding("S+DOWN",SELECT_NEXT_LINE);

		addKeyBinding("C+ENTER",REPEAT);

	}

	/**

	 * Adds a key binding to this input handler. The key binding is

	 * a list of white space separated key strokes of the form

	 * <i>[modifiers+]key</i> where modifier is C for Control, A for Alt,

	 * or S for Shift, and key is either a character (a-z) or a field

	 * name in the KeyEvent class prefixed with VK_ (e.g., BACK_SPACE)

	 * @param keyBinding The key binding

	 * @param action The action

	 */

	public void addKeyBinding(String keyBinding, ActionListener action)

	{

	        Hashtable current = bindings;

		StringTokenizer st = new StringTokenizer(keyBinding);

		while(st.hasMoreTokens())

		{

			KeyStroke keyStroke = parseKeyStroke(st.nextToken());

			if(keyStroke == null)

				return;

			if(st.hasMoreTokens())

			{

				Object o = current.get(keyStroke);

				if(o instanceof Hashtable)

					current = (Hashtable)o;

				else

				{

					o = new Hashtable();

					current.put(keyStroke,o);

					current = (Hashtable)o;

				}

			}

			else

				current.put(keyStroke,action);

		}

	}

	/**

	 * Removes a key binding from this input handler. This is not yet

	 * implemented.

	 * @param keyBinding The key binding

	 */

	public void removeKeyBinding(String keyBinding)

	{

		throw new InternalError("Not yet implemented");

	}

	/**

	 * Removes all key bindings from this input handler.

	 */

	public void removeAllKeyBindings()

	{

		bindings.clear();

	}

	/**

	 * Returns a copy of this input handler that shares the same

	 * key bindings. Setting key bindings in the copy will also

	 * set them in the original.

	 */

	public InputHandler copy()

	{

		return new DefaultInputHandler(this);

	}

	/**

	 * Handle a key pressed event. This will look up the binding for

	 * the key stroke and execute it.

	 */

	public void keyPressed(KeyEvent evt)

	{

		int keyCode = evt.getKeyCode();

		int modifiers = evt.getModifiers();

		if(keyCode == KeyEvent.VK_CONTROL ||

			keyCode == KeyEvent.VK_SHIFT ||

			keyCode == KeyEvent.VK_ALT ||

			keyCode == KeyEvent.VK_META)

			return;

		if((modifiers & ~KeyEvent.SHIFT_MASK) != 0

			|| evt.isActionKey()

			|| keyCode == KeyEvent.VK_BACK_SPACE

			|| keyCode == KeyEvent.VK_DELETE

			|| keyCode == KeyEvent.VK_ENTER

			|| keyCode == KeyEvent.VK_TAB

			|| keyCode == KeyEvent.VK_ESCAPE)

		{

			if(grabAction != null)

			{

				handleGrabAction(evt);

				return;

			}

			KeyStroke keyStroke = KeyStroke.getKeyStroke(keyCode,

				modifiers);

			Object o = currentBindings.get(keyStroke);

			if(o == null)

			{

				// Don't beep if the user presses some

				// key we don't know about unless a

				// prefix is active. Otherwise it will

				// beep when caps lock is pressed, etc.

				if(currentBindings != bindings)

				{

					Toolkit.getDefaultToolkit().beep();

					// F10 should be passed on, but C+e F10

					// shouldn't

					repeatCount = 0;

					repeat = false;

					evt.consume();

				}

				currentBindings = bindings;

				return;

			}

			else if(o instanceof ActionListener)

			{

				currentBindings = bindings;

				executeAction(((ActionListener)o),

					evt.getSource(),null);

				evt.consume();

				return;

			}

			else if(o instanceof Hashtable)

			{

				currentBindings = (Hashtable)o;

				evt.consume();

				return;

			}

		}

	}

	/**

	 * Handle a key typed event. This inserts the key into the text area.

	 */

	public void keyTyped(KeyEvent evt)

	{

		int modifiers = evt.getModifiers();

		char c = evt.getKeyChar();

		if(c != KeyEvent.CHAR_UNDEFINED &&

			(modifiers & KeyEvent.ALT_MASK) == 0)

		{

			if(c >= 0x20 && c != 0x7f)

			{

				KeyStroke keyStroke = KeyStroke.getKeyStroke(

					Character.toUpperCase(c));

				Object o = currentBindings.get(keyStroke);

				if(o instanceof Hashtable)

				{

					currentBindings = (Hashtable)o;

					return;

				}

				else if(o instanceof ActionListener)

				{

					currentBindings = bindings;

					executeAction((ActionListener)o,

						evt.getSource(),

						String.valueOf(c));

					return;

				}

				currentBindings = bindings;

				if(grabAction != null)

				{

					handleGrabAction(evt);

					return;

				}

				// 0-9 adds another 'digit' to the repeat number

				if(repeat && Character.isDigit(c))

				{

					repeatCount *= 10;

					repeatCount += (c - '0');

					return;

				}

				executeAction(INSERT_CHAR,evt.getSource(),

					String.valueOf(evt.getKeyChar()));

				repeatCount = 0;

				repeat = false;

			}

		}

	}

	/**

	 * Converts a string to a keystroke. The string should be of the

	 * form <i>modifiers</i>+<i>shortcut</i> where <i>modifiers</i>

	 * is any combination of A for Alt, C for Control, S for Shift

	 * or M for Meta, and <i>shortcut</i> is either a single character,

	 * or a keycode name from the <code>KeyEvent</code> class, without

	 * the <code>VK_</code> prefix.

	 * @param keyStroke A string description of the key stroke

	 */

	public static KeyStroke parseKeyStroke(String keyStroke)

	{

		if(keyStroke == null)

			return null;

		int modifiers = 0;

		int index = keyStroke.indexOf('+');

		if(index != -1)

		{

			for(int i = 0; i < index; i++)

			{

				switch(Character.toUpperCase(keyStroke

					.charAt(i)))

				{

				case 'A':

					modifiers |= InputEvent.ALT_MASK;

					break;

				case 'C':

					modifiers |= InputEvent.CTRL_MASK;

					break;

				case 'M':

					modifiers |= InputEvent.META_MASK;

					break;

				case 'S':

					modifiers |= InputEvent.SHIFT_MASK;

					break;

				}

			}

		}

		String key = keyStroke.substring(index + 1);

		if(key.length() == 1)

		{

			char ch = Character.toUpperCase(key.charAt(0));

			if(modifiers == 0)

				return KeyStroke.getKeyStroke(ch);

			else

				return KeyStroke.getKeyStroke(ch,modifiers);

		}

		else if(key.length() == 0)

		{

			System.err.println("Invalid key stroke: " + keyStroke);

			return null;

		}

		else

		{

			int ch;

			try

			{

				ch = KeyEvent.class.getField("VK_".concat(key))

					.getInt(null);

			}

			catch(Exception e)

			{

				System.err.println("Invalid key stroke: "

					+ keyStroke);

				return null;

			}

			return KeyStroke.getKeyStroke(ch,modifiers);

		}

	}

	// private members

	private Hashtable bindings;

	private Hashtable currentBindings;

	private DefaultInputHandler(DefaultInputHandler copy)

	{

		bindings = currentBindings = copy.bindings;

	}

}

/*

 * XMLTokenMarker.java - XML token marker

 * Copyright (C) 1998, 1999 Slava Pestov

 * Copyright (C) 2001 Tom Bradford

 *

 * You may use and modify this package for any purpose. Redistribution is

 * permitted, in both source and binary form, provided that this notice

 * remains intact in all source distributions of this package.

 */

package org.apache.batik.apps.svgbrowser.srcview;

import javax.swing.text.Segment;

/**

 * XML Token Marker Rewrite

 *

 * @author Tom Bradford

 * @version $Id: XMLTokenMarker.java,v 1.5 2001/07/29 20:45:43 tom Exp $

 */

public class XMLTokenMarker extends TokenMarker {

   public XMLTokenMarker() {

   }

   public byte markTokensImpl(byte token, Segment line, int lineIndex) {

      char[] array = line.array;

      int offset = line.offset;

      int lastOffset = offset;

      int length = line.count + offset;

      // Ugly hack to handle multi-line tags

      boolean sk1 = token == Token.KEYWORD1;

      for ( int i = offset; i < length; i++ ) {

         int ip1 = i+1;

         char c = array[i];

         switch ( token ) {

            case Token.NULL: // text

               switch ( c ) {

                  case '<':

                     addToken(i-lastOffset, token);

                     lastOffset = i;

                     if ( SyntaxUtilities.regionMatches(false, line, ip1, "!--") ) {

                        i += 3;

                        token = Token.COMMENT1;

                     }

                     else if ( array[ip1] == '!' ) {

                        i += 1;

                        token = Token.COMMENT2;

                     }

                     else if ( array[ip1] == '?' ) {

                        i += 1;

                        token = Token.KEYWORD3;

                     }

                     else

                        token = Token.KEYWORD1;

                     break;

                  case '&':

                     addToken(i - lastOffset, token);

                     lastOffset = i;

                     token = Token.LABEL;

                     break;

               }

               break;

            case Token.KEYWORD1: // tag

               switch ( c ) {

                  case '>':

                     addToken(ip1-lastOffset, token);

                     lastOffset = ip1;

                     token = Token.NULL;

                     sk1 = false;

                     break;

                  case ' ':

                  case '\t':

                     addToken(i-lastOffset, token);

                     lastOffset = i;

                     token = Token.KEYWORD2;

                     sk1 = false;

                     break;

                  default:

                     if ( sk1 ) {

                        token = Token.KEYWORD2;

                        sk1 = false;

                     }

                     break;

               }

               break;

            case Token.KEYWORD2: // attribute

               switch ( c ) {

                   case '>':

                     addToken(ip1-lastOffset, token);

                     lastOffset = ip1;

                     token = Token.NULL;

                     break;

                  case '/':

                     addToken(i-lastOffset, token);

                     lastOffset = i;

                     token = Token.KEYWORD1;

                     break;

                  case '=':

                     addToken(i-lastOffset, token);

                     lastOffset = i;

                     token = Token.OPERATOR;

               }

               break;

            case Token.OPERATOR: // equal for attribute

               switch ( c ) {

                  case '\"':

                  case '\'':

                     addToken(i-lastOffset, token);

                     lastOffset = i;

                     if ( c == '\"' )

                        token = Token.LITERAL1;

                     else

                        token = Token.LITERAL2;

                     break;

               }

               break;

            case Token.LITERAL1:

            case Token.LITERAL2: // strings

               if ( ( token == Token.LITERAL1 && c == '\"' )

                 || ( token == Token.LITERAL2 && c == '\'' ) ) {

                  addToken(ip1-lastOffset, token);

                  lastOffset = ip1;

                  token = Token.KEYWORD1;

               }

               break;

            case Token.LABEL: // entity

               if ( c == ';' ) {

                  addToken(ip1-lastOffset, token);

                  lastOffset = ip1;

                  token = Token.NULL;

                  break;

               }

               break;

            case Token.COMMENT1: // Inside a comment

               if ( SyntaxUtilities.regionMatches(false, line, i, "-->") ) {

                  addToken((i+3)-lastOffset, token);

                  lastOffset = i+3;

                  token = Token.NULL;

               }

               break;

            case Token.COMMENT2: // Inside a declaration

               if ( SyntaxUtilities.regionMatches(false, line, i, ">") ) {

                  addToken(ip1-lastOffset, token);

                  lastOffset = ip1;

                  token = Token.NULL;

               }

               break;

            case Token.KEYWORD3: // Inside a processor instruction

               if ( SyntaxUtilities.regionMatches(false, line, i, "?>") ) {

                  addToken((i+2)-lastOffset, token);

                  lastOffset = i+2;

                  token = Token.NULL;

               }

               break;

            default:

               throw new InternalError("Invalid state: " + token);

         }

      }

      switch ( token ) {

         case Token.LABEL:

            addToken(length-lastOffset, Token.INVALID);

            token = Token.NULL;

            break;

         default:

            addToken(length-lastOffset, token);

            break;

      }

      return token;

   }

}

/*

 * TextAreaDefaults.java - Encapsulates default values for various settings

 * Copyright (C) 1999 Slava Pestov

 *

 * You may use and modify this package for any purpose. Redistribution is

 * permitted, in both source and binary form, provided that this notice

 * remains intact in all source distributions of this package.

 */

package org.apache.batik.apps.svgbrowser.srcview;

import javax.swing.JPopupMenu;

import java.awt.Color;

/**

 * Encapsulates default settings for a text area. This can be passed

 * to the constructor once the necessary fields have been filled out.

 * The advantage of doing this over calling lots of set() methods after

 * creating the text area is that this method is faster.

 */

public class TextAreaDefaults

{

	private static TextAreaDefaults DEFAULTS;

	public InputHandler inputHandler;

	public SyntaxDocument document;

	public boolean editable;

	public boolean caretVisible;

	public boolean caretBlinks;

	public boolean blockCaret;

	public int electricScroll;

	public int cols;

	public int rows;

	public SyntaxStyle[] styles;

	public Color caretColor;

	public Color selectionColor;

	public Color lineHighlightColor;

	public boolean lineHighlight;

	public Color bracketHighlightColor;

	public boolean bracketHighlight;

	public Color eolMarkerColor;

	public boolean eolMarkers;

	public boolean paintInvalid;

	public JPopupMenu popup;

	/**

	 * Returns a new TextAreaDefaults object with the default values filled

	 * in.

	 */

	public static TextAreaDefaults getDefaults()

	{

		if(DEFAULTS == null)

		{

			DEFAULTS = new TextAreaDefaults();

			DEFAULTS.inputHandler = new DefaultInputHandler();

			DEFAULTS.inputHandler.addDefaultKeyBindings();

			DEFAULTS.document = new SyntaxDocument();

			DEFAULTS.editable = true;

			DEFAULTS.caretVisible = true;

			DEFAULTS.caretBlinks = true;

			DEFAULTS.electricScroll = 3;

			DEFAULTS.cols = 80;

			DEFAULTS.rows = 25;

			DEFAULTS.styles = SyntaxUtilities.getDefaultSyntaxStyles();

			DEFAULTS.caretColor = Color.red;

			DEFAULTS.selectionColor = new Color(0xccccff);

			DEFAULTS.lineHighlightColor = new Color(0xe0e0e0);

			DEFAULTS.lineHighlight = true;

			DEFAULTS.bracketHighlightColor = Color.black;

			DEFAULTS.bracketHighlight = true;

			DEFAULTS.eolMarkerColor = new Color(0x009999);

			DEFAULTS.eolMarkers = true;

			DEFAULTS.paintInvalid = true;

		}

		return DEFAULTS;

	}

}

package org.apache.batik.apps.svgbrowser.srcview;

import java.awt.BorderLayout;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.Font;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileOutputStream;

import java.io.OutputStream;

import java.io.OutputStreamWriter;

import java.util.HashMap;

import java.util.Locale;

import java.util.Map;

import java.util.MissingResourceException;

import java.util.ResourceBundle;

import javax.swing.AbstractAction;

import javax.swing.Action;

import javax.swing.BorderFactory;

import javax.swing.Box;

import javax.swing.BoxLayout;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JCheckBox;

import javax.swing.JDialog;

import javax.swing.JFileChooser;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JMenuBar;

import javax.swing.JPanel;

import javax.swing.JTextField;

import javax.swing.JToggleButton;

import javax.swing.JToolBar;

import javax.swing.SwingUtilities;

import javax.swing.UIManager;

import javax.swing.event.CaretEvent;

import javax.swing.event.CaretListener;

import javax.swing.event.DocumentEvent;

import javax.swing.event.DocumentListener;

import javax.swing.filechooser.FileFilter;

import org.apache.batik.apps.svgbrowser.AboutDialog;

import org.apache.batik.apps.svgbrowser.Application;

import org.apache.batik.swing.svg.SVGUserAgent;

import org.apache.batik.util.gui.resource.ActionMap;

import org.apache.batik.util.gui.resource.ButtonFactory;

import org.apache.batik.util.gui.resource.MenuFactory;

import org.apache.batik.util.gui.resource.MissingListenerException;

import org.apache.batik.util.gui.resource.ResourceManager;

public class SourceViewFrame extends JFrame implements ActionMap {

	public static final String RESOURCES = "org.apache.batik.apps.svgbrowser.srcview.resources.SourceViewFrame";

	// The action names

	public static final String SAVE_AS_ACTION = "SaveAsAction";

	public static final String CLOSE_ACTION = "CloseAction";

	public static final String UNDO_ACTION = "UndoAction";

	public static final String REDO_ACTION = "RedoAction";

	public static final String CUT_ACTION = "CutAction";

	public static final String COPY_ACTION = "CopyAction";

	public static final String PASTE_ACTION = "PasteAction";

	public static final String DELETE_ACTION = "DeleteAction";

	public static final String SELECT_ALL_ACTION = "SelectAllAction";

	public static final String FIND_ACTION = "FindAction";

	public static final String FIND_CLOSE_ACTION = "FindCloseAction";

	public static final String FIND_AGAIN_ACTION = "FindAgainAction";

	public static final String FIND_PREVIOUS_ACTION = "FindPreviousAction";

	public static final String HIGHLIGHT_ALL_ACTION = "HighlightAllAction";

	public static final String GOTO_LINE_ACTION = "GotoLineAction";

	public static final String TEXT_SIZE_INCREASE_ACTION = "TextSizeIncreaseAction";

	public static final String TEXT_SIZE_DECREASE_ACTION = "TextSizeDecreaseAction";

	public static final String TEXT_SIZE_NORMAL_ACTION = "TextSizeNormalAction";

	public static final String SYNTAX_HIGHLIGHTING_ACTION = "SyntaxHighlightingAction";

	public static final String ABOUT_ACTION = "AboutAction";

	protected static final float[] FONT_SIZES = { 6, 8, 10, 11, 12, 14, 18, 28,

			36, 72 };

	/**

	 * The resource bundle

	 */

	protected static ResourceBundle bundle;

	/**

	 * The resource manager

	 */

	protected static ResourceManager resources;

	static {

		bundle = ResourceBundle.getBundle(RESOURCES, Locale.getDefault());

		resources = new ResourceManager(bundle);

	}

	/**

	 * The SVG user agent.

	 */

	protected SVGUserAgent userAgent;

	/**

	 * The current application.

	 */

	protected Application application;

	/**

	 * The text to be displayed in the source viewer

	 */

	protected String sourceText;

	/**

	 * The syntax highlighted text area

	 */

	protected JEditTextArea textArea;

	/**

	 * TokenMarker used by syntax highlighted text area to tokenize text

	 */

	protected TokenMarker tokenMarker;

	/**

	 * The current save path.

	 */

	protected File currentSavePath = new File("");

	/**

	 * The find bar.

	 */

	protected JToolBar findbar;

	/**

	 * Label to display status messages in the find bar

	 */

	protected FindBarMessage findbarMessage;

	/**

	 * The status bar.

	 */

	protected StatusBar statusBar;

	/**

	 * The current font size index (into the array FONT_SIZES)

	 */

	protected int fontSizeIndex;

	/**

	 * The default font size index (into the array FONT_SIZES)

	 */

	protected final int defaultFontSizeIndex = 4;

	/**

	 * Creates a new source viewer frame.

	 */

	public SourceViewFrame(Application app, String text, SVGUserAgent agt)

			throws MissingResourceException {

		application = app;

		sourceText = text;

		userAgent = agt;

		listeners.put(SAVE_AS_ACTION, new SaveAsAction());

		listeners.put(CLOSE_ACTION, new CloseAction());

		listeners.put(UNDO_ACTION, new UndoAction());

		listeners.put(REDO_ACTION, new RedoAction());

		listeners.put(CUT_ACTION, new CutAction());

		listeners.put(COPY_ACTION, new CopyAction());

		listeners.put(PASTE_ACTION, new PasteAction());

		listeners.put(DELETE_ACTION, new DeleteAction());

		listeners.put(SELECT_ALL_ACTION, new SelectAllAction());

		listeners.put(FIND_ACTION, new FindAction());

		listeners.put(FIND_CLOSE_ACTION, new FindCloseAction());

		listeners.put(FIND_AGAIN_ACTION, new FindAgainAction());

		listeners.put(FIND_PREVIOUS_ACTION, new FindPreviousAction());

		listeners.put(HIGHLIGHT_ALL_ACTION, new HighlightAllAction());

		listeners.put(GOTO_LINE_ACTION, new GotoLineAction());

		listeners.put(TEXT_SIZE_INCREASE_ACTION, new TextSizeIncreaseAction());

		listeners.put(TEXT_SIZE_DECREASE_ACTION, new TextSizeDecreaseAction());

		listeners.put(TEXT_SIZE_NORMAL_ACTION, new TextSizeNormalAction());

		listeners.put(SYNTAX_HIGHLIGHTING_ACTION,

				new SyntaxHighlightingAction());

		listeners.put(ABOUT_ACTION, new AboutAction());

		// Create the menu

		MenuFactory mf = new MenuFactory(bundle, this);

		// TODO:Remove this and use specialized version (commented out below)

		JMenuBar mb = mf.createJMenuBar("MenuBar");

		// JMenuBar mb = mf.createJMenuBar("MenuBar", application

		// .getUISpecialization());

		setJMenuBar(mb);

		// Create the central panel

		JPanel center = new JPanel(new BorderLayout());

		getContentPane().add(center, BorderLayout.CENTER);

		// Create syntax-highlighted text area

		textArea = new JEditTextArea();

		textArea.setText(sourceText);

		tokenMarker = new XMLTokenMarker();

		textArea.setTokenMarker(tokenMarker);

		fontSizeIndex = defaultFontSizeIndex;

		TextAreaPainter painter = textArea.getPainter();

		painter.setFont(new Font("Monospaced", Font.PLAIN,

				(int) (FONT_SIZES[fontSizeIndex])));

		textArea.addCaretListener(new CaretListener() {

			public void caretUpdate(CaretEvent e) {

				JEditTextArea a = (JEditTextArea) e.getSource();

				int row = a.getCaretLine() + 1;

				int col = a.getCaretPosition() - a.getLineStartOffset(row - 1)

						+ 1;

				statusBar.setPosition(row, col);

			}

		});

		center.add(textArea);

		// Create find bar (initially invisible)

		ButtonFactory bf = new ButtonFactory(bundle, this);

		findbar = new JToolBar();

		findbar.setVisible(false);

		findbar.setFloatable(false);

		findbar.add(bf.createJToolbarButton("FindBarClose"));

		findbar

				.add(new JLabel(resources.getString("FindBar.label.find")

						+ ": "));

		final JTextField findText = new JTextField(20);

		JPanel p = new JPanel();

		p.setOpaque(false);

		p.add(findText);

		p.setMinimumSize(p.getPreferredSize());

		p.setMaximumSize(p.getPreferredSize());

		findbar.add(p);

		final JButton next = bf.createJToolbarButton("FindBarNext");

		next.setEnabled(false);

		findbar.add(next);

		final JButton previous = bf.createJToolbarButton("FindBarPrevious");

		previous.setEnabled(false);

		findbar.add(previous);

		final JToggleButton highlightAll = bf

				.createJToolbarToggleButton("FindBarHighlightAll");

		highlightAll.setEnabled(false);

		findbar.add(highlightAll);

		JCheckBox matchCase = bf.createJCheckBox("FindBarMatchCase");

		matchCase.setOpaque(false);

		findbar.add(matchCase);

		findbarMessage = new FindBarMessage();

		findbar.add(findbarMessage);

		findText.getDocument().addDocumentListener(new DocumentListener() {

			public void changedUpdate(DocumentEvent e) {

				update();

			}

			public void insertUpdate(DocumentEvent e) {

				update();

			}

			public void removeUpdate(DocumentEvent e) {

				update();

			}

			private void update() {

				String str = findText.getText().trim();

				boolean enabled = !str.equals("");

				next.setEnabled(enabled);

				previous.setEnabled(enabled);

				highlightAll.setEnabled(enabled);

				if (enabled) {

					if (!find(str, DIRECTION_DOWN)) {

						findText.setBackground(new Color(255, 128, 128));

					}

				} else {

					findbarMessage.setMessage(FindBarMessage.NONE);

					findText.setBackground(UIManager

							.getColor("TextField.background"));

				}

			}

		});

		center.add(findbar, BorderLayout.SOUTH);

		// Create status bar

		statusBar = new StatusBar();

		getContentPane().add(statusBar, BorderLayout.SOUTH);

	}

	protected static ImageIcon notFoundIcon, continueFromTopIcon;

	protected static String notFoundStr, continueFromTopStr;

	static {

		notFoundStr = resources.getString("FindBarNotFound.text");

		notFoundIcon = new ImageIcon(SourceViewFrame.class

				.getResource(resources.getString("FindBarNotFound.icon")));

		continueFromTopStr = resources.getString("FindBarContinueFromTop.text");

		continueFromTopIcon = new ImageIcon(SourceViewFrame.class

				.getResource(resources.getString("FindBarContinueFromTop.icon")));

	}

	protected class FindBarMessage extends JLabel {

		public static final int NONE = 0, NOT_FOUND = 1, CONTINUE_FROM_TOP = 2;

		public void setMessage(int type) {

			switch (type) {

			case NOT_FOUND:

				setIcon(notFoundIcon);

				setText(notFoundStr);

				break;

			case CONTINUE_FROM_TOP:

				setIcon(continueFromTopIcon);

				setText(continueFromTopStr);

				break;

			case NONE:

			default:

				setIcon(null);

				setText("");

				break;

			}

		}

	}

	/**

	 * Save the document as a different file

	 */

	public class SaveAsAction extends AbstractAction {

		public void actionPerformed(ActionEvent e) {

			JFileChooser fileChooser;

			fileChooser = new JFileChooser(

					currentSavePath.isAbsolute() ? currentSavePath

							: currentSavePath.getAbsoluteFile());

			fileChooser.setDialogTitle(resources.getString("SaveAs.title"));

			fileChooser.setFileHidingEnabled(false);

			fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);

			fileChooser.addChoosableFileFilter(new FileFilter() {

				public boolean accept(File f) {

					if (f == null) {

						return false;

					}

					if (f.isDirectory()) {

						return true;

					}

					String fileName = f.getName().toLowerCase();

					return fileName.endsWith(".svg");

				}

				public String getDescription() {

					return "SVG Document";

				}

			});

			int choice = fileChooser.showSaveDialog(SourceViewFrame.this);

			if (choice != JFileChooser.APPROVE_OPTION)

				return;

			final File f = fileChooser.getSelectedFile();

			statusBar.setMessage(resources.getString("Message.saveAs"));

			currentSavePath = f;

			OutputStreamWriter w = null;

			try {

				OutputStream tos = null;

				tos = new FileOutputStream(f);

				tos = new BufferedOutputStream(tos);

				w = new OutputStreamWriter(tos, "utf-8");

			} catch (Exception ex) {

				userAgent.displayError(ex);

				return;

			}

			final OutputStreamWriter writer = w;

			final Runnable doneRun = new Runnable() {

				public void run() {

					String doneStr = resources.getString("Message.done");

					statusBar.setMessage(doneStr);

				}

			};

			try {

				writer.write(textArea.getText());

				writer.close();

				SwingUtilities.invokeLater(doneRun);

			} catch (Exception ex) {

				userAgent.displayError(ex);

			}

		}

	}

	/**

	 * Closes the source viewer

	 */

	public class CloseAction extends AbstractAction {

		public void actionPerformed(ActionEvent e) {

			dispose();

		}

	}

	/**

	 * Undo last action

	 */

	public class UndoAction extends AbstractAction {

		public void actionPerformed(ActionEvent e) {

		}

	}

	/**

	 * Redo last undone action

	 */

	public class RedoAction extends AbstractAction {

		public void actionPerformed(ActionEvent e) {

		}

	}

	/**

	 * Cut selected text

	 */

	public class CutAction extends AbstractAction {

		public void actionPerformed(ActionEvent e) {

			textArea.cut();

		}

	}

	/**

	 * Copy selected text

	 */

	public class CopyAction extends AbstractAction {

		public void actionPerformed(ActionEvent e) {

			textArea.copy();

		}

	}

	/**

	 * Paste copied text

	 */

	public class PasteAction extends AbstractAction {

		public void actionPerformed(ActionEvent e) {

			textArea.paste();

		}

	}