TextBuffer that is based on
* ITextSelection and IDocument.
*/
public class TextBuffer {
private static class DocumentRegion extends TextRegion {
IRegion fRegion;
public DocumentRegion(IRegion region) {
fRegion = region;
}
public int getOffset() {
return fRegion.getOffset();
}
public int getLength() {
return fRegion.getLength();
}
}
public class Block {
public String content;
public int offsetDelta;
}
private IDocument fDocument;
private static final TextBufferFactory fgFactory = new TextBufferFactory();
TextBuffer(IDocument document) {
fDocument = document;
Assert.isNotNull(fDocument);
}
/**
* Returns the number of characters in this text buffer.
*
* @return the number of characters in this text buffer
*/
public int getLength() {
return fDocument.getLength();
}
/**
* Returns the number of lines in this text buffer.
*
* @return the number of lines in this text buffer
*/
public int getNumberOfLines() {
return fDocument.getNumberOfLines();
}
/**
* Returns the character at the given offset in this text buffer.
*
* @param offset
* a text buffer offset
* @return the character at the offset
* @exception IndexOutOfBoundsException
* if the offset argument is negative or not
* less than the length of this text buffer.
*/
public char getChar(int offset) {
try {
return fDocument.getChar(offset);
} catch (BadLocationException e) {
throw new ArrayIndexOutOfBoundsException(e.getMessage());
}
}
/**
* Returns the whole content of the text buffer.
*
* @return the whole content of the text buffer
*/
public String getContent() {
return fDocument.get();
}
/**
* Returns length characters starting from the specified position.
*
* @return the characters specified by the given text region. Returns
* null
* if text range is illegal
*/
public String getContent(int start, int length) {
try {
return fDocument.get(start, length);
} catch (BadLocationException e) {
return null;
}
}
public Block getBlockContent(int start, int length, int tabWidth) {
Block result = new Block();
StringBuffer buffer = new StringBuffer();
int lineOffset = getLineInformationOfOffset(start).getOffset();
if (start > lineOffset) {
String line = getContent(lineOffset, start - lineOffset);
String indent = Strings.getIndentString(line, tabWidth);
result.offsetDelta = -indent.length();
buffer.append(indent);
}
final int end = start + length;
TextRegion region = getLineInformationOfOffset(end);
lineOffset = region.getOffset();
// Cursor is at beginning of next line
if (lineOffset == end) {
int lineNumber = getLineOfOffset(lineOffset);
if (lineNumber > 0) {
length = length - getLineDelimiter(lineNumber - 1).length();
}
}
if (buffer.length() == 0) {
result.content = getContent(start, length);
} else {
buffer.append(getContent(start, length));
result.content = buffer.toString();
}
return result;
}
/**
* Returns the preferred line delimiter to be used for this text buffer.
*
* @return the preferred line delimiter
*/
public String getLineDelimiter() {
String lineDelimiter = getLineDelimiter(0);
if (lineDelimiter == null)
lineDelimiter = System.getProperty("line.separator", "\n"); //$NON-NLS-1$ //$NON-NLS-2$
return lineDelimiter;
}
/**
* Returns the line delimiter used for the given line number. Returns
* null
* if the line number is out of range.
*
* @return the line delimiter used by the given line number or
* null
*/
public String getLineDelimiter(int line) {
try {
return fDocument.getLineDelimiter(line);
} catch (BadLocationException e) {
return null;
}
}
/**
* Returns the line for the given line number. If there isn't any line for
* the given line number, null is returned.
*
* @return the line for the given line number or null
*/
public String getLineContent(int line) {
try {
IRegion region = fDocument.getLineInformation(line);
return fDocument.get(region.getOffset(), region.getLength());
} catch (BadLocationException e) {
return null;
}
}
/**
* Returns the line indent for the given line. If there isn't any line for
* the given line number, -1 is returned.
*
* @return the line indent for the given line number of -1
*/
public int getLineIndent(int lineNumber, int tabWidth) {
return Strings.computeIndent(getLineContent(lineNumber), tabWidth);
}
/**
* Returns a region of the specified line. The region contains the offset
* and the length of the line excluding the line's delimiter. Returns
* null if the line doesn't exist.
*
* @param line
* the line of interest
* @return a line description or null if the given line
* doesn't exist
*/
public TextRegion getLineInformation(int line) {
try {
return new DocumentRegion(fDocument.getLineInformation(line));
} catch (BadLocationException e) {
return null;
}
}
/**
* Returns a line region of the specified offset. The region contains the
* offset and the length of the line excluding the line's delimiter. Returns
* null if the line doesn't exist.
*
* @param offset
* an offset into a line
* @return a line description or null if the given line
* doesn't exist
*/
public TextRegion getLineInformationOfOffset(int offset) {
try {
return new DocumentRegion(fDocument
.getLineInformationOfOffset(offset));
} catch (BadLocationException e) {
return null;
}
}
/**
* Returns the line number that contains the given position. If there isn't
* any line that contains the position, null is returned. The
* returned string is a copy and doesn't contain the line delimiter.
*
* @return the line that contains the given offset or null if
* line doesn't exist
*/
public int getLineOfOffset(int offset) {
try {
return fDocument.getLineOfOffset(offset);
} catch (BadLocationException e) {
return -1;
}
}
/**
* Returns the line that contains the given position. If there isn't any
* line that contains the position, null is returned. The
* returned string is a copy and doesn't contain the line delimiter.
*
* @return the line that contains the given offset or null if
* line doesn't exist
*/
public String getLineContentOfOffset(int offset) {
try {
IRegion region = fDocument.getLineInformationOfOffset(offset);
return fDocument.get(region.getOffset(), region.getLength());
} catch (BadLocationException e) {
return null;
}
}
/**
* Converts the text determined by the region [offset, length] into an array
* of lines. The lines are copies of the original lines and don't contain
* any line delimiter characters.
*
* @return the text converted into an array of strings. Returns
* null if the region lies outside the source.
*/
public String[] convertIntoLines(int offset, int length,
boolean lastNewLineCreateEmptyLine) {
try {
String text = fDocument.get(offset, length);
ILineTracker tracker = new DefaultLineTracker();
tracker.set(text);
int size = tracker.getNumberOfLines();
int lastLine = size - 1;
List result = new ArrayList(size);
for (int i = 0; i < size; i++) {
IRegion region = tracker.getLineInformation(i);
String line = getContent(offset + region.getOffset(), region
.getLength());
if (i < lastLine
|| !"".equals(line) || lastNewLineCreateEmptyLine) //$NON-NLS-1$
result.add(line);
}
return (String[]) result.toArray(new String[result.size()]);
} catch (BadLocationException e) {
return null;
}
}
/**
* Subsitutes the given text for the specified text position
*
* @param offset
* the starting offset of the text to be replaced
* @param length
* the length of the text to be replaced
* @param text
* the substitution text
* @exception CoreException
* if the text position [offset, length] is invalid.
*/
public void replace(int offset, int length, String text)
throws CoreException {
try {
fDocument.replace(offset, length, text);
} catch (BadLocationException e) {
IStatus s = new Status(IStatus.ERROR, PHPeclipsePlugin
.getPluginId(), PHPStatusConstants.INTERNAL_ERROR,
TextManipulationMessages.getFormattedString(
"TextBuffer.wrongRange", //$NON-NLS-1$
new Object[] { new Integer(offset),
new Integer(length) }), e);
throw new CoreException(s);
}
}
public void replace(TextRange range, String text) throws CoreException {
replace(range.fOffset, range.fLength, text);
}
// ---- Special methods used by the TextBufferEditor
/**
* Releases this text buffer.
*/
/* package */void release() {
}
/* package */void registerUpdater(IDocumentListener listener) {
fDocument.addDocumentListener(listener);
}
/* package */void unregisterUpdater(IDocumentListener listener) {
fDocument.removeDocumentListener(listener);
}
// ---- Factory methods
// ----------------------------------------------------------------
/**
* Acquires a text buffer for the given file. If a text buffer for the given
* file already exists, then that one is returned.
*
* @param file
* the file for which a text buffer is requested
* @return a managed text buffer for the given file
* @exception CoreException
* if it was not possible to acquire the text buffer
*/
public static TextBuffer acquire(IFile file) throws CoreException {
return fgFactory.acquire(file);
}
/**
* Releases the given text buffer.
*
* @param buffer
* the text buffer to be released
*/
public static void release(TextBuffer buffer) {
fgFactory.release(buffer);
}
/**
* Commits the changes made to the given text buffer to the underlying
* storage system.
*
* @param buffer
* the text buffer containing the changes to be committed.
* @param force
* if true the text buffer is committed in any
* case. If false the text buffer is ONLY
* committed if the client is the last one that holds a reference
* to the text buffer. Clients of this method must make sure that
* they don't call this method from within an
* IWorkspaceRunnable.
* @param pm
* the progress monitor used to report progress if committing is
* necessary
*/
public static void commitChanges(TextBuffer buffer, boolean force,
IProgressMonitor pm) throws CoreException {
fgFactory.commitChanges(buffer, force, pm);
}
/**
* Creates a new TextBuffer for the given file. The returned
* buffer will not be managed. Any subsequent call to create
* with the same file will return a different text buffer.
*
* If the file is currently open in a text editor, the editors content is
* copied into the returned TextBuffer. Otherwise the
* content is read from disk.
*
* @param file
* the file for which a text buffer is to be created
* @return a new unmanaged text buffer
* @exception CoreException
* if it was not possible to create the text buffer
*/
public static TextBuffer create(IFile file) throws CoreException {
return fgFactory.create(file);
}
/**
* Creates a new TextBuffer for the string. The returned
* buffer will not be managed. Any subsequent call to create
* with the identical string will return a different text buffer.
*
* @param content
* the text buffer's content
* @return a new unmanaged text buffer
*/
public static TextBuffer create(String content) {
return fgFactory.create(content);
}
// Unclear which methods are needed if we get the new save model. If optimal
// no
// save is needed at all.
public static void save(TextBuffer buffer, IProgressMonitor pm)
throws CoreException {
fgFactory.save(buffer, pm);
}
public static void aboutToChange(TextBuffer buffer) throws CoreException {
fgFactory.aboutToChange(buffer);
}
public static void changed(TextBuffer buffer) throws CoreException {
fgFactory.changed(buffer);
}
}