Adds an undo listener for notification of any changes.

  Adds an undo listener for notification of any changes.
Undo/Redo operations performed on the UndoableEdit
will cause the appropriate DocumentEvent to be fired to keep
the view(s) in sync with the model.
Parameters:
- listener - the UndoableEditListener to add
See Also: Document.addUndoableEditListener(javax.swing.event.UndoableEditListener),

  Creates a document branch element, that can contain other elements.

  Creates a document branch element, that can contain other elements.
Returns: the element
Parameters:
- parent - the parent element
- a - the attributes

  Creates a document leaf element.

  Creates a document leaf element.
Hook through which elements are created to represent the
document structure. Because this implementation keeps
structure and content separate, elements grow automatically
when content is extended so splits of existing elements
follow. The document itself gets to decide how to generate
elements to give flexibility in the type of elements used.
Returns: the new element
Parameters:
- parent - the parent element
- a - the attributes for the element
- p0 - the beginning of the range >= 0
- p1 - the end of the range >= p0

  Returns a position that will track change as the document is altered.

  Returns a position that will track change as the document is altered.

This method is thread safe, although most Swing methods are not. Please see How to Use Threads for more information.
Returns: the position
Parameters:
- offs - the position in the model >= 0
Throws:
- BadLocationException - if the given position does not represent a valid location in the associated document
See Also: Document.createPosition(int),

  Gives a diagnostic dump.

  Gives a diagnostic dump.
Parameters:
- out - the output stream

  Notifies all listeners that have registered interest for notification on this event type.

  Notifies all listeners that have registered interest for
notification on this event type. The event instance
is lazily created using the parameters passed into
the fire method.
Parameters:
- e - the event
See Also: EventListenerList,

  Notifies all listeners that have registered interest for notification on this event type.

  Notifies all listeners that have registered interest for
notification on this event type. The event instance
is lazily created using the parameters passed into
the fire method.
Parameters:
- e - the event
See Also: EventListenerList,

  Notifies all listeners that have registered interest for notification on this event type.

  Notifies all listeners that have registered interest for
notification on this event type. The event instance
is lazily created using the parameters passed into
the fire method.
Parameters:
- e - the event
See Also: EventListenerList,

  Notifies all listeners that have registered interest for notification on this event type.

  Notifies all listeners that have registered interest for
notification on this event type. The event instance
is lazily created using the parameters passed into
the fire method.
Parameters:
- e - the event
See Also: EventListenerList,

  Gets the asynchronous loading priority.

  Gets the asynchronous loading priority. If less than zero,
the document should not be loaded asynchronously.
Returns: the asynchronous loading priority, or -1 if the document should not be loaded asynchronously

  Fetches the context for managing attributes.

  Fetches the context for managing attributes. This
method effectively establishes the strategy used
for compressing AttributeSet information.
Returns: the context

  Returns the root element of the bidirectional structure for this document.

  Returns the root element of the bidirectional structure for this
document. Its children represent character runs with a given
Unicode bidi level.

  Gets the content for the document.

  Gets the content for the document.
Returns: the content

  Fetches the current writing thread if there is one.

  Fetches the current writing thread if there is one.
This can be used to distinguish whether a method is
being called as part of an existing modification or
if a lock needs to be acquired and a new transaction
started.
Returns: the thread actively modifying the document or null if there are no modifications in progress

  Returns the DocumentFilter that is responsible for filtering of insertion/removal.

  Returns the DocumentFilter that is responsible for
filtering of insertion/removal. A null return value
implies no filtering is to occur.
Returns: the DocumentFilter
Since: 1.4
See Also: AbstractDocument.setDocumentFilter(javax.swing.text.DocumentFilter),

  Returns an array of all the document listeners registered on this document.

  Returns an array of all the document listeners
registered on this document.
Returns: all of this document's DocumentListeners or an empty array if no document listeners are currently registered
Since: 1.4
See Also: AbstractDocument.addDocumentListener(javax.swing.event.DocumentListener), AbstractDocument.removeDocumentListener(javax.swing.event.DocumentListener),

  Supports managing a set of properties.

  Supports managing a set of properties. Callers
can use the documentProperties dictionary
to annotate the document with document-wide properties.
Returns: a non-null Dictionary
See Also: AbstractDocument.setDocumentProperties(java.util.Dictionary),

  Returns a position that represents the end of the document.

  Returns a position that represents the end of the document. The
position returned can be counted on to track change and stay
located at the end of the document.
Returns: the position

  Returns the length of the data.

  Returns the length of the data. This is the number of
characters of content that represents the users data.
Returns: the length >= 0
See Also: Document.getLength(),

  Returns an array of all the objects currently registered as FooListeners upon this document.

  Returns an array of all the objects currently registered as FooListeners upon this document. FooListeners are registered using the addFooListener method.

You can specify the listenerType argument with a class literal, such as FooListener.class. For example, you can query a document d for its document listeners with the following code:

DocumentListener[] mls = (DocumentListener[])(d.getListeners(DocumentListener.class));

If no such listeners exist, this method returns an empty array.
Returns: an array of all objects registered as FooListeners on this component, or an empty array if no such listeners have been added
Parameters:
- listenerType - the type of listeners requested; this parameter should specify an interface that descends from java.util.EventListener
Throws:
- ClassCastException - if listenerType doesn't specify a class or interface that implements java.util.EventListener
Since: 1.3
See Also: AbstractDocument.getDocumentListeners(), AbstractDocument.getUndoableEditListeners(),

  A convenience method for looking up a property value.

  A convenience method for looking up a property value. It is
equivalent to:

 getDocumentProperties().get(key);
 

Returns: the value of this property or null
Parameters:
- key - the non-null property key
See Also: AbstractDocument.getDocumentProperties(),

  Gets all root elements defined.

  Gets all root elements defined. Typically, there
will only be one so the default implementation
is to return the default root element.
Returns: the root element

  Returns a position that represents the start of the document.

  Returns a position that represents the start of the document. The
position returned can be counted on to track change and stay
located at the beginning of the document.
Returns: the position

  Gets a sequence of text from the document.

  Gets a sequence of text from the document.
Returns: the text
Parameters:
- offset - the starting offset >= 0
- length - the number of characters to retrieve >= 0
Throws:
- BadLocationException - the range given includes a position that is not a valid position within the document
See Also: Document.getText(int, int),

  Fetches the text contained within the given portion of the document.

  Fetches the text contained within the given portion of the document.

If the partialReturn property on the txt parameter is false, the data returned in the Segment will be the entire length requested and may or may not be a copy depending upon how the data was stored. If the partialReturn property is true, only the amount of text that can be returned without creating a copy is returned. Using partial returns will give better performance for situations where large parts of the document are being scanned. The following is an example of using the partial return to access the entire document:

   int nleft = doc.getDocumentLength();
   Segment text = new Segment();
   int offs = 0;
   text.setPartialReturn(true);   
   while (nleft > 0) {
       doc.getText(offs, nleft, text);
       // do something with text
       nleft -= text.count;
       offs += text.count;
   }
 

Parameters:
- offset - the starting offset >= 0
- length - the number of characters to retrieve >= 0
- txt - the Segment object to retrieve the text into
Throws:
- BadLocationException - the range given includes a position that is not a valid position within the document

  Returns an array of all the undoable edit listeners registered on this document.

  Returns an array of all the undoable edit listeners
registered on this document.
Returns: all of this document's UndoableEditListeners or an empty array if no undoable edit listeners are currently registered
Since: 1.4
See Also: AbstractDocument.addUndoableEditListener(javax.swing.event.UndoableEditListener), AbstractDocument.removeUndoableEditListener(javax.swing.event.UndoableEditListener),

Performs the actual work of inserting the text; it is assumed the caller has obtained a write lock before invoking this.

  Performs the actual work of the remove.

  Performs the actual work of the remove. It is assumed the caller
will have obtained a writeLock before invoking this.

  Inserts some content into the document.

  Inserts some content into the document. Inserting content causes a write lock to be held while the actual changes are taking place, followed by notification to the observers on the thread that grabbed the write lock.

This method is thread safe, although most Swing methods are not. Please see How to Use Threads for more information.
Parameters:
- offs - the starting offset >= 0
- str - the string to insert; does nothing with null/empty strings
- a - the attributes for the inserted content
Throws:
- BadLocationException - the given insert position is not a valid position within the document
See Also: Document.insertString(int, java.lang.String, javax.swing.text.AttributeSet),

Returns true if the text in the range p0 to p1 is left to right.

  Updates any document structure as a result of text removal.

  Updates any document structure as a result of text removal. This
method is called after the text has been removed from the Content.
This will happen within a write lock. If a subclass
of this class reimplements this method, it should delegate to the
superclass as well.
Parameters:
- chng - a description of the change

  A convenience method for storing up a property value.

  A convenience method for storing up a property value. It is
equivalent to:

 getDocumentProperties().put(key, value);
 

If value is null this method will
remove the property.
Parameters:
- key - the non-null key
- value - the property value
See Also: AbstractDocument.getDocumentProperties(),

  Acquires a lock to begin reading some state from the document.

  Acquires a lock to begin reading some state from the
document. There can be multiple readers at the same time.
Writing blocks the readers until notification of the change
to the listeners has been completed. This method should
be used very carefully to avoid unintended compromise
of the document. It should always be balanced with a
readUnlock.
See Also: AbstractDocument.readUnlock(),

  Does a read unlock.

  Does a read unlock. This signals that one
of the readers is done. If there are no more readers
then writing can begin again. This should be balanced
with a readLock, and should occur in a finally statement
so that the balance is guaranteed. The following is an
example.

     readLock();
     try {
         // do something
     } finally {
         readUnlock();
     }
 

See Also: AbstractDocument.readLock(),

  Removes some content from the document.

  Removes some content from the document. Removing content causes a write lock to be held while the actual changes are taking place. Observers are notified of the change on the thread that called this method.

This method is thread safe, although most Swing methods are not. Please see How to Use Threads for more information.
Parameters:
- offs - the starting offset >= 0
- len - the number of characters to remove >= 0
Throws:
- BadLocationException - the given remove position is not a valid position within the document
See Also: Document.remove(int, int),

  Removes an undo listener.

  Removes an undo listener.
Parameters:
- listener - the UndoableEditListener to remove
See Also: Document.removeDocumentListener(javax.swing.event.DocumentListener),

  This allows the model to be safely rendered in the presence of currency, if the model supports being updated asynchronously.

  This allows the model to be safely rendered in the presence of currency, if the model supports being updated asynchronously. The given runnable will be executed in a way that allows it to safely read the model with no changes while the runnable is being executed. The runnable itself may not make any mutations.

This is implemented to aquire a read lock for the duration of the runnables execution. There may be multiple runnables executing at the same time, and all writers will be blocked while there are active rendering runnables. If the runnable throws an exception, its lock will be safely released. There is no protection against a runnable that never exits, which will effectively leave the document locked for it's lifetime.

If the given runnable attempts to make any mutations in this implementation, a deadlock will occur. There is no tracking of individual rendering threads to enable detecting this situation, but a subclass could incur the overhead of tracking them and throwing an error.

This method is thread safe, although most Swing methods are not. Please see How to Use Threads for more information.
Parameters:
- r - the renderer to execute

  Deletes the region of text from offset to offset + length, and replaces it with text.

  Deletes the region of text from offset to
offset + length, and replaces it with text.
It is up to the implementation as to how this is implemented, some
implementations may treat this as two distinct operations: a remove
followed by an insert, others may treat the replace as one atomic
operation.
Parameters:
- offset - index of child element
- length - length of text to delete, may be 0 indicating don't delete anything
- text - text to insert, null indicates no text to insert
- attrs - AttributeSet indicating attributes of inserted text, null is legal, and typically treated as an empty attributeset, but exact interpretation is left to the subclass
Throws:
- BadLocationException - the given position is not a valid position within the document
Since: 1.4

  Sets the asynchronous loading priority.

  Sets the asynchronous loading priority.
Parameters:
- p - the new asynchronous loading priority; a value less than zero indicates that the document should not be loaded asynchronously

  Sets the DocumentFilter.

  Sets the DocumentFilter. The DocumentFilter
is passed insert and remove to conditionally
allow inserting/deleting of the text. A null value
indicates that no filtering will occur.
Parameters:
- filter - the DocumentFilter used to constrain text
Since: 1.4
See Also: AbstractDocument.getDocumentFilter(),

  Replaces the document properties dictionary for this document.

  Replaces the document properties dictionary for this document.
Parameters:
- x - the new dictionary
See Also: AbstractDocument.getDocumentProperties(),

  Update the bidi element structure as a result of the given change to the document.

  Update the bidi element structure as a result of the given change
to the document. The given change will be updated to reflect the
changes made to the bidi structure.

This method assumes that every offset in the model is contained in
exactly one paragraph. This method also assumes that it is called
after the change is made to the default element structure.

  Acquires a lock to begin mutating the document this lock protects.

  Acquires a lock to begin mutating the document this lock protects. There can be no writing, notification of changes, or reading going on in order to gain the lock. Additionally a thread is allowed to gain more than one writeLock, as long as it doesn't attempt to gain additional writeLocks from within document notification. Attempting to gain a writeLock from within a DocumentListener notification will result in an IllegalStateException. The ability to obtain more than one writeLock per thread allows subclasses to gain a writeLock, perform a number of operations, then release the lock.

Calls to writeLock must be balanced with calls to writeUnlock, else the Document will be left in a locked state so that no reading or writing can be done.
Throws:
- IllegalStateException - thrown on illegal lock attempt. If the document is implemented properly, this can only happen if a document listener attempts to mutate the document. This situation violates the bean event model where order of delivery is not guaranteed and all listeners should be notified before further mutations are allowed.

  Releases a write lock previously obtained via writeLock.

  Releases a write lock previously obtained via writeLock.
After decrementing the lock count if there are no oustanding locks
this will allow a new writer, or readers.
See Also: AbstractDocument.writeLock(),