/** Update the child views in response to a document event. */
void updateChildren(DocumentEvent e, Shape a) {
Element elem = getElement();
DocumentEvent.ElementChange ec = e.getChange(elem);
// This occurs when syntax highlighting only changes on lines
// (i.e. beginning a multiline comment).
if (e.getType() == DocumentEvent.EventType.CHANGE) {
// System.err.println("Updating the damage due to a CHANGE event...");
// FIXME: Make me repaint more intelligently.
getContainer().repaint();
// damageLineRange(startLine,endLine, a, host);
} else if (ec != null) {
// the structure of this element changed.
Element[] removedElems = ec.getChildrenRemoved();
Element[] addedElems = ec.getChildrenAdded();
View[] added = new View[addedElems.length];
for (int i = 0; i < addedElems.length; i++) added[i] = new WrappedLine(addedElems[i]);
// System.err.println("Replacing " + removedElems.length +
// " children with " + addedElems.length);
replace(ec.getIndex(), removedElems.length, added);
// should damge a little more intelligently.
if (a != null) {
preferenceChanged(null, true, true);
getContainer().repaint();
}
}
// update font metrics which may be used by the child views
updateMetrics();
}
/**
* A change in the text fields.
*
* @param e the document event.
*/
private void documentChanged(DocumentEvent e) {
if (e.getDocument().equals(fileCountField.getDocument())) {
// set file count only if its un integer
try {
int newFileCount = Integer.valueOf(fileCountField.getText());
fileCountField.setForeground(Color.black);
LoggingUtilsActivator.getPacketLoggingService()
.getConfiguration()
.setLogfileCount(newFileCount);
} catch (Throwable t) {
fileCountField.setForeground(Color.red);
}
} else if (e.getDocument().equals(fileSizeField.getDocument())) {
// set file size only if its un integer
try {
int newFileSize = Integer.valueOf(fileSizeField.getText());
fileSizeField.setForeground(Color.black);
LoggingUtilsActivator.getPacketLoggingService()
.getConfiguration()
.setLimit(newFileSize * 1000);
} catch (Throwable t) {
fileSizeField.setForeground(Color.red);
}
}
}
@Override
public void insertUpdate(DocumentEvent e) {
try {
// Check for change in lines only if a newline
// character is inserted.
String insertion = e.getDocument().getText(e.getOffset(), e.getLength());
if (insertion.contains("\n")) documentChanged();
} catch (BadLocationException ex) {
/* nothing to do */
}
}
/**
* Forwards the given <code>DocumentEvent</code> to the child views that need to be notified of
* the change to the model. If there were changes to the element this view is responsible for,
* that should be considered when forwarding (i.e. new child views should not get notified).
*
* @param ec changes to the element this view is responsible for (may be <code>null</code> if
* there were no changes).
* @param e the change information from the associated document
* @param a the current allocation of the view
* @param f the factory to use to rebuild if the view has children
* @see #insertUpdate
* @see #removeUpdate
* @see #changedUpdate
* @since 1.3
*/
protected void forwardUpdate(
DocumentEvent.ElementChange ec, DocumentEvent e, Shape a, ViewFactory f) {
Element elem = getElement();
int pos = e.getOffset();
int index0 = getViewIndex(pos, Position.Bias.Forward);
if (index0 == -1 && e.getType() == DocumentEvent.EventType.REMOVE && pos >= getEndOffset()) {
// Event beyond our offsets. We may have represented this, that is
// the remove may have removed one of our child Elements that
// represented this, so, we should foward to last element.
index0 = getViewCount() - 1;
}
int index1 = index0;
View v = (index0 >= 0) ? getView(index0) : null;
if (v != null) {
if ((v.getStartOffset() == pos) && (pos > 0)) {
// If v is at a boundary, forward the event to the previous
// view too.
index0 = Math.max(index0 - 1, 0);
}
}
if (e.getType() != DocumentEvent.EventType.REMOVE) {
index1 = getViewIndex(pos + e.getLength(), Position.Bias.Forward);
if (index1 < 0) {
index1 = getViewCount() - 1;
}
}
int hole0 = index1 + 1;
int hole1 = hole0;
Element[] addedElems = (ec != null) ? ec.getChildrenAdded() : null;
if ((addedElems != null) && (addedElems.length > 0)) {
hole0 = ec.getIndex();
hole1 = hole0 + addedElems.length - 1;
}
// forward to any view not in the forwarding hole
// formed by added elements (i.e. they will be updated
// by initialization.
index0 = Math.max(index0, 0);
for (int i = index0; i <= index1; i++) {
if (!((i >= hole0) && (i <= hole1))) {
v = getView(i);
if (v != null) {
Shape childAlloc = getChildAllocation(i, a);
forwardUpdateToView(v, e, childAlloc, f);
}
}
}
}
/**
* Gives notification that something was inserted into the document in a location that this view
* is responsible for. This is implemented to simply update the children.
*
* @param changes The change information from the associated document.
* @param a the current allocation of the view
* @param f the factory to use to rebuild if the view has children
* @see View#insertUpdate
*/
public void insertUpdate(DocumentEvent changes, Shape a, ViewFactory f) {
updateChildren(changes, a);
Rectangle alloc = ((a != null) && isAllocationValid()) ? getInsideAllocation(a) : null;
int pos = changes.getOffset();
View v = getViewAtPosition(pos, alloc);
if (v != null) v.insertUpdate(changes, alloc, f);
}
private boolean handleEmptyTextField(DocumentEvent e) {
if (e.getDocument().getLength() <= 0) {
button.setEnabled(false);
alreadyEnabled = false;
return true;
}
return false;
}
/**
* Repaint the region of change covered by the given document event. Damages the line that begins
* the range to cover the case when the insert/remove is only on one line. If lines are added or
* removed, damages the whole view. The longest line is checked to see if it has changed.
*/
protected void updateDamage(DocumentEvent changes, Shape a, ViewFactory f) {
Component host = getContainer();
updateMetrics();
Element elem = getElement();
DocumentEvent.ElementChange ec = changes.getChange(elem);
Element[] added = (ec != null) ? ec.getChildrenAdded() : null;
Element[] removed = (ec != null) ? ec.getChildrenRemoved() : null;
if (((added != null) && (added.length > 0)) || ((removed != null) && (removed.length > 0))) {
// lines were added or removed...
if (added != null) {
int addedAt = ec.getIndex(); // FIXME: Is this correct?????
for (int i = 0; i < added.length; i++) possiblyUpdateLongLine(added[i], addedAt + i);
}
if (removed != null) {
for (int i = 0; i < removed.length; i++) {
if (removed[i] == longLine) {
longLineWidth = -1; // Must do this!!
calculateLongestLine();
break;
}
}
}
preferenceChanged(null, true, true);
host.repaint();
}
// This occurs when syntax highlighting only changes on lines
// (i.e. beginning a multiline comment).
else if (changes.getType() == DocumentEvent.EventType.CHANGE) {
// System.err.println("Updating the damage due to a CHANGE event...");
int startLine = changes.getOffset();
int endLine = changes.getLength();
damageLineRange(startLine, endLine, a, host);
} else {
Element map = getElement();
int line = map.getElementIndex(changes.getOffset());
damageLineRange(line, line, a, host);
if (changes.getType() == DocumentEvent.EventType.INSERT) {
// check to see if the line is longer than current
// longest line.
Element e = map.getElement(line);
if (e == longLine) {
// We must recalculate longest line's width here
// because it has gotten longer.
longLineWidth = getLineWidth(line);
preferenceChanged(null, true, false);
} else {
// If long line gets updated, update the status bars too.
if (possiblyUpdateLongLine(e, line)) preferenceChanged(null, true, false);
}
} else if (changes.getType() == DocumentEvent.EventType.REMOVE) {
if (map.getElement(line) == longLine) {
// removed from longest line... recalc
longLineWidth = -1; // Must do this!
calculateLongestLine();
preferenceChanged(null, true, false);
}
}
}
}
public void insertUpdate(DocumentEvent evt) {
documentChanged(evt);
int offset = evt.getOffset();
int length = evt.getLength();
int newStart;
int newEnd;
if (selectionStart > offset || (selectionStart == selectionEnd && selectionStart == offset))
newStart = selectionStart + length;
else newStart = selectionStart;
if (selectionEnd >= offset) newEnd = selectionEnd + length;
else newEnd = selectionEnd;
select(newStart, newEnd);
}
/**
* Forwards the <code>DocumentEvent</code> to the give child view. This simply messages the view
* with a call to <code>insertUpdate</code>, <code>removeUpdate</code>, or <code>changedUpdate
* </code> depending upon the type of the event. This is called by <a
* href="#forwardUpdate">forwardUpdate</a> to forward the event to children that need it.
*
* @param v the child view to forward the event to
* @param e the change information from the associated document
* @param a the current allocation of the view
* @param f the factory to use to rebuild if the view has children
* @see #forwardUpdate
* @since 1.3
*/
protected void forwardUpdateToView(View v, DocumentEvent e, Shape a, ViewFactory f) {
DocumentEvent.EventType type = e.getType();
if (type == DocumentEvent.EventType.INSERT) {
v.insertUpdate(e, a, f);
} else if (type == DocumentEvent.EventType.REMOVE) {
v.removeUpdate(e, a, f);
} else {
v.changedUpdate(e, a, f);
}
}
public void insertUpdate(DocumentEvent e) {
Document doc = e.getDocument();
try {
prop.set(doc.getText(0, doc.getLength()));
} catch (BadLocationException b) {
// Once again, no idea what this is supposed to be.
// I don't think I like this interface much :-(.
System.out.println(b);
}
}
public void removeUpdate(DocumentEvent evt) {
documentChanged(evt);
int offset = evt.getOffset();
int length = evt.getLength();
int newStart;
int newEnd;
if (selectionStart > offset) {
if (selectionStart > offset + length) newStart = selectionStart - length;
else newStart = offset;
} else newStart = selectionStart;
if (selectionEnd > offset) {
if (selectionEnd > offset + length) newEnd = selectionEnd - length;
else newEnd = offset;
} else newEnd = selectionEnd;
select(newStart, newEnd);
}
protected void documentChanged(DocumentEvent evt) {
DocumentEvent.ElementChange ch = evt.getChange(document.getDefaultRootElement());
int count;
if (ch == null) count = 0;
else count = ch.getChildrenAdded().length - ch.getChildrenRemoved().length;
int line = getLineOfOffset(evt.getOffset());
if (count == 0) {
painter.invalidateLine(line);
}
// do magic stuff
else if (line < firstLine) {
setFirstLine(firstLine + count);
}
// end of magic stuff
else {
painter.invalidateLineRange(line, firstLine + visibleLines);
updateScrollBars();
}
}
void updateTheLabel(DocumentEvent e) {
Document doc = (Document) e.getDocument();
String text = null;
try {
text = doc.getText(0, doc.getLength());
doc = null;
} catch (BadLocationException ex) {
text = null;
}
if (text != null) {
try {
double number = Double.parseDouble(text);
if (number > 1) {
label.setText(labelPair.getPlural());
} else {
label.setText(labelPair.getSingular());
}
} catch (NumberFormatException ex) {
// Do nothing
} finally {
text = null;
}
}
}
/**
* Gives notification from the document that attributes were changed in a location that this view
* is responsible for. To reduce the burden to subclasses, this functionality is spread out into
* the following calls that subclasses can reimplement:
*
* <ol>
* <li><a href="#updateChildren">updateChildren</a> is called if there were any changes to the
* element this view is responsible for. If this view has child views that are represent the
* child elements, then this method should do whatever is necessary to make sure the child
* views correctly represent the model.
* <li><a href="#forwardUpdate">forwardUpdate</a> is called to forward the DocumentEvent to the
* appropriate child views.
* <li><a href="#updateLayout">updateLayout</a> is called to give the view a chance to either
* repair its layout, to reschedule layout, or do nothing.
* </ol>
*
* @param e the change information from the associated document
* @param a the current allocation of the view
* @param f the factory to use to rebuild if the view has children
* @see View#changedUpdate
*/
public void changedUpdate(DocumentEvent e, Shape a, ViewFactory f) {
if (getViewCount() > 0) {
Element elem = getElement();
DocumentEvent.ElementChange ec = e.getChange(elem);
if (ec != null) {
if (!updateChildren(ec, e, f)) {
// don't consider the element changes they
// are for a view further down.
ec = null;
}
}
forwardUpdate(ec, e, a, f);
updateLayout(ec, e, a);
}
}