import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.text.*;

/*
 *  Class to manage protected text within a Document. There are two different
 *  but related functions provided by this class:
 *
 *  a) protect the text in the Document from being changed or deleted
 *  b) control caret navigation so that the caret is only ever positioned on
 *     text that can be changed.
 *
 *  Note: this class was designed to be used the the ProtectedTextComponent
 *  class, although it can be used on its own when highlighting of the
 *  protected text is not a requirement.
 */
public class ProtectedDocument
{
	private AbstractDocument doc;
	private Map<Position, Position> positions = new HashMap<Position, Position>();

	public ProtectedDocument(JTextComponent component)
	{
		doc = (AbstractDocument)component.getDocument();
		doc.setDocumentFilter( new ProtectedDocumentFilter() );
		component.setNavigationFilter( new ProtectedNavigationFilter(component) );
	}

	/*
	 *  Specify a portion of text to be protected
	 *
	 *  Note: when protecting and entire line the start offset should be the line
	 *        start - 1. This prevents a character from being inserted at the
	 *        start of the line.
	 */
	public void protect(int start, int end)
	{
		try
		{
			positions.put(doc.createPosition(start), doc.createPosition(end));
		}
		catch(BadLocationException ble)
		{
			System.out.println(ble);
		}
	}

	/*
	 *  Class to prevent the removal or changing of text in protected areas
	 *  of the Document.
	 */
	class ProtectedDocumentFilter extends DocumentFilter
	{
		/*
		 *	Prevent inserts by the program
		 */
		public void insertString(FilterBypass fb, int offset, String str, AttributeSet a)
			throws BadLocationException
		{
			if (isInsertProtected(offset))
			{
				Toolkit.getDefaultToolkit().beep();
			}
			else
			{
				super.insertString(fb, offset, str, a);
			}
		}

		/*
		 *  Prevent removal and insertions by the GUI components
		 */
		public void replace(FilterBypass fb, int offset, int length, String str, AttributeSet a)
			throws BadLocationException
		{
			if (length != 0  && isRemoveProtected(offset, length))
			{
				Toolkit.getDefaultToolkit().beep();
			}
			else if (isInsertProtected(offset))
			{
				Toolkit.getDefaultToolkit().beep();
			}
			else
			{
				super.replace(fb, offset, length, str, a);
			}
		}

		/*
		 *  Prevent removal of text
		 */
		public void remove(DocumentFilter.FilterBypass fb, int offset, int length)
			throws BadLocationException
		{
			if (length == 0) length++;

			if (isRemoveProtected(offset, length))
				Toolkit.getDefaultToolkit().beep();
			else
				super.remove(fb, offset, length);
		}

		/*
		 *	Check if we are attempting to remove protected text. Don't
		 *  remove when:
		 *
		 *  a) the starting offset is contained within a protected block
		 *  b) the ending offset is contained within a protected block
		 *  c) the start and end offsets span a contained block
		 */
		private boolean isRemoveProtected(int start, int length)
		{
			int end = start + length - 1;

			for (Map.Entry<Position, Position> me: positions.entrySet())
			{
				int positionStart = me.getKey().getOffset();
				int positionEnd = me.getValue().getOffset();

				if (start >= positionStart && start <= positionEnd)
					return true;

				if (end >= positionStart && end <= positionEnd)
					return true;

				if (start < positionStart && end > positionEnd)
					return true;
			}

			return false;
		}

		/*
		 *  Check if we are attempting to insert text in the middle of a
		 *  protected block. This should never happen since the navigation
		 *  filter should prevent the caret from being positioned here.
		 *  However, the program could invoke an insertString(...) method.
		 *
		 *  Offset 0, is a special case because the Position object managed by
		 *  the Document will never update its start position, so the size of
		 *  protected area would continue to grow as text is inserted.
		 */
		private boolean isInsertProtected(int start)
		{
			for (Map.Entry<Position, Position> me: positions.entrySet())
			{
				int positionStart = me.getKey().getOffset();
				int positionEnd = me.getValue().getOffset();

				if (start == 0 && positionStart == 0)
					return true;

				if (start > positionStart && start <= positionEnd)
					return true;
			}

			return false;
		}

	}	// end ProtectedDocumentFilter

	/*
	 *  This class will control the navigation of the caret. The caret will
	 *  skip over protected pieces of text and position itself at the
	 *  next unprotected text.
	 */
	class ProtectedNavigationFilter extends NavigationFilter implements MouseListener
	{
		private JTextComponent component;
		private boolean isMousePressed = false;
		private int mouseDot = -1;
		private int lastDot = -1;

		public ProtectedNavigationFilter(JTextComponent component)
		{
			this.component = component;
			this.component.addMouseListener( this );
		}

		/*
		 *  Override for normal caret movement
		 */
		public void setDot(NavigationFilter.FilterBypass fb, int dot, Position.Bias bias)
		{
			// Moving forwards in the Document

			if (dot > lastDot)
			{
				dot = getForwardDot(dot);
				super.setDot(fb, dot, bias);
			}
			else  // Moving backwards in the Document
			{
				dot = getBackwardDot(dot);
				super.setDot(fb, dot, bias);
			}

			lastDot = dot;
		}

		/*
		 *  Override for text selection as the caret is moved
		 */
		public void moveDot(NavigationFilter.FilterBypass fb, int dot, Position.Bias bias)
		{
			//  The mouse dot is used when dragging the mouse to prevent flickering

			lastDot = isMousePressed ? mouseDot : lastDot;

			//  Moving forwards in the Document

			if (dot > lastDot)
			{
				lastDot = dot;
				dot = getForwardDot(dot);
				super.moveDot(fb, dot, bias);
			}
			else  //  Moving backwards in the Document
			{
				lastDot = dot;
				dot = getBackwardDot(dot);
				super.moveDot(fb, dot, bias);
			}

			lastDot = dot;
		}

		/*
		 *  Attempting to move the caret forward in the Document. Skip forward
		 *  when we attempt to position the caret at a protected offset.
		 */
		private int getForwardDot(int dot)
		{
			for (Map.Entry<Position, Position> me: positions.entrySet())
			{
				int positionStart = me.getKey().getOffset();
				int positionEnd = me.getValue().getOffset();

				if (dot > positionStart && dot <= positionEnd)
					return positionEnd + 1;
			}

			return dot;
		}

		/*
		 *  Attempting to move the caret forward in the Document. Skip forward
		 *  when we attempt to position the caret at a protected offset.
		 */
		private int getBackwardDot(int dot)
		{
			for (Map.Entry<Position, Position> me: positions.entrySet())
			{
				int positionStart = me.getKey().getOffset();
				int positionEnd = me.getValue().getOffset();

				if (dot <= positionEnd && dot >= positionStart)
					return positionStart;
			}

			return dot;
		}

	//  Implement the MouseListener

		public void mousePressed( MouseEvent e )
		{
			//  Track the caret position so it is easier to determine whether
			//  we are moving forwards/backwards when dragging the mouse.

			isMousePressed = true;
			mouseDot = component.getCaretPosition();
		}

		public void mouseReleased( MouseEvent e )
		{
			isMousePressed = false;
		}

		public void mouseEntered( MouseEvent e ) {}
		public void mouseExited( MouseEvent e ) {}
		public void mouseClicked( MouseEvent e ) {}
	}	//  end ProtectedNavigationFilter
}	// end ProtectedDocument