/*
* (C) Copyright IBM Corp. 1998-2004. All Rights Reserved.
*
* The program is provided "as is" without any warranty express or
* implied, including the warranty of non-infringement and the implied
* warranties of merchantibility and fitness for a particular purpose.
* IBM will not be liable for any damages suffered by you as a result
* of using the Program. In no event will IBM be liable for any
* special, indirect or consequential damages or lost profits even if
* IBM has been advised of the possibility of their occurrence. IBM
* will not be liable for any third party claims against you.
*/
package com.ibm.richtext.textpanel;
import java.awt.Adjustable;
import java.awt.Component;
import java.awt.datatransfer.Clipboard;
import com.ibm.richtext.textlayout.attributes.AttributeMap;
import com.ibm.richtext.styledtext.StyleModifier;
import com.ibm.richtext.styledtext.MConstText;
import com.ibm.richtext.styledtext.MText;
import com.ibm.richtext.styledtext.StyledText;
import com.ibm.richtext.textformat.TextOffset;
/**
* Implementation class for TextPanel and JTextPanel.
*/
final class ATextPanelImpl {
static final String COPYRIGHT =
"(C) Copyright IBM Corp. 1998-1999 - All Rights Reserved";
private RunStrategy fRunStrategy = null;
private TextComponent fTextComponent = null;
private TextSelection fSelection = null;
private TextEditBehavior fEditBehavior = null;
private MText fText = null;
private PanelEventBroadcaster fBroadcaster;
private KeyRemap fRemap = KeyRemap.getIdentityRemap();
// This is a little ugly. TextPanel supports its modified
// flag whether or not it is editable, or even selectable.
// So if there's no command log to keep track of the flag
// state then its done right here in TextPanel. If the
// panel is editable this flag is ignored.
private boolean fModified = false;
static final TextPanelSettings fgDefaultSettings = new TextPanelSettings();
static TextPanelSettings getDefaultSettings() {
return (TextPanelSettings) fgDefaultSettings.clone();
}
ATextPanelImpl(RunStrategy runStrategy,
TextPanelSettings settings,
MConstText initialText,
Clipboard clipboard,
MTextPanel client,
Adjustable horzSb,
Adjustable vertSb) {
fRunStrategy = runStrategy;
fBroadcaster = new PanelEventBroadcaster(client);
Scroller scroller = null;
if (settings.getScrollable()) {
scroller = new Scroller(horzSb, vertSb);
}
StyledTextClipboard textClipboard =
StyledTextClipboard.getClipboardFor(clipboard);
fText = new StyledText();
if (initialText != null) {
fText.append(initialText);
}
fTextComponent = new TextComponent(fText,
settings.getDefaultValues(),
settings.getWraps(),
TextComponent.WINDOW_WIDTH,
TextComponent.DEFAULT_INSET,
textClipboard,
settings.getScrollable(),
scroller,
fBroadcaster);
if (scroller != null) {
scroller.setClient(fTextComponent);
}
// May have to wait until component has host to do this:
if (settings.getSelectable()) {
fSelection = new TextSelection(fTextComponent,
fBroadcaster,
fRunStrategy);
fSelection.addToOwner(fTextComponent);
if (settings.getEditable()) {
fEditBehavior = new TextEditBehavior(
fTextComponent, fSelection, fBroadcaster, fRemap);
fEditBehavior.addToOwner(fTextComponent);
}
}
}
FakeComponent getTextComponent() {
return fTextComponent;
}
/**
* Add the given TextPanelListener to the listeners which will
* receive update notifications from this TextPanel.
* @param listener the listener to add
*/
public void addListener(TextPanelListener listener) {
fBroadcaster.addListener(listener);
}
/**
* Remove the given TextPanelListener from the listeners which will
* receive update notifications from this TextPanel.
* @param listener the listener to remove
*/
public void removeListener(TextPanelListener listener) {
fBroadcaster.removeListener(listener);
}
/**
* You know what this does...
*/
private static int pin(int value, int min, int max) {
if (min > max) {
throw new IllegalArgumentException("Invalid range");
}
if (value < min) {
value = min;
}
else if (value > max) {
value = max;
}
return value;
}
//============
// Text Access
//============
/**
* Set the document to <tt>newText</tt>. This operation
* modifies the text in the TextPanel. It does not modify or adopt
* <tt>newText</tt>. This method sets the selection an insertion point at
* the end of the text.
* @param newText the text which will replace the current text.
*/
public void setText(MConstText newText) {
replaceRange(newText, 0, getTextLength());
}
/**
* Append the given text to the end of the document. Equivalent to
* <tt>insert(newText, getTextLength())</tt>.
* @param newText the text to append to the document
*/
public void append(MConstText newText) {
int length = getTextLength();
replaceRange(newText, length, length);
}
/**
* Insert the given text into the document at the given position.
* Equivalent to
* <tt>replaceRange(newText, position, position)</tt>.
* @param newText the text to insert into the document.
* @param position the position in the document where the
* text will be inserted
*/
public void insert(MConstText newText, int position) {
replaceRange(newText, position, position);
}
/**
* Replace the given range with <tt>newText</tt>. After this
* operation the selection range is an insertion point at the
* end of the new text.
* @param newText the text with which to replace the range
* @param start the beginning of the range to replace
* @param end the end of the range to replace
*/
public void replaceRange(MConstText newText, int start, int end) {
int length = getTextLength();
start = pin(start, 0, length);
end = pin(end, start, length);
if (fSelection != null) {
// If we're selectable, but not editable, we'll temporarily
// make ourselves editable to change the text. A little funny
// but there's a lot of code for getting caret stuff right,
// and this is not a common operation anyway.
TextEditBehavior behavior;
if (fEditBehavior == null) {
behavior = new TextEditBehavior(fTextComponent, fSelection, fBroadcaster, fRemap);
behavior.addToOwner(fTextComponent);
}
else {
behavior = fEditBehavior;
}
TextOffset newSelection = new TextOffset(start + newText.length(),
TextOffset.AFTER_OFFSET);
TextReplacement replacement = new TextReplacement(start, end,
newText,
newSelection,
newSelection);
fTextComponent.textControlEventOccurred(Behavior.REPLACE,
replacement);
if (fEditBehavior == null) {
behavior.removeFromOwner();
}
}
else {
MText oldText = fTextComponent.getModifiableText();
fTextComponent.stopBackgroundFormatting();
oldText.replaceAll(newText);
fTextComponent.reformatAndDrawText(0, newText.length(), null, null, null, null);
}
}
/**
* Return the length of the text document in the TextPanel.
* @return the length of the text document in the TextPanel
*/
public int getTextLength() {
return fTextComponent.getText().length();
}
/**
* Return the text document in the TextPanel.
* @return the text document in the TextPanel.
*/
public MConstText getText() {
return fTextComponent.getText();
}
//============
// Selection Access
//============
/**
* Return the offset of the start of the selection.
*/
public int getSelectionStart() {
if (fSelection != null) {
return fSelection.getStart().fOffset;
}
else {
return 0;
}
}
/**
* Return the offset of the end of the selection.
*/
public int getSelectionEnd() {
if (fSelection != null) {
return fSelection.getEnd().fOffset;
}
else {
return 0;
}
}
/**
* Set the beginning of the selection range. This is
* equivalent to <tt>select(selectionStart, getSelectionEnd())</tt>.
* @param selectionStart the start of the new selection range
*/
public void setSelectionStart(int selectionStart) {
select(selectionStart, getSelectionEnd());
}
/**
* Set the end of the selection range. This is
* equivalent to <tt>select(getSelectionStart(), selectionEnd)</tt>.
* @param selectionStart the start of the new selection range
*/
public void setSelectionEnd(int selectionEnd) {
select(getSelectionStart(), selectionEnd);
}
/**
* Set the selection range to an insertion point at the given
* offset. This is equivalent to
* <tt>select(position, position)</tt>.
* @param position the offset of the new insertion point
*/
public void setCaretPosition(int position) {
select(position, position);
}
/**
* Set the selection range to the given range. The range start
* is pinned between 0 and the text length; the range end is pinned
* between the range start and the end of the text. These semantics
* are identical to those of <tt>java.awt.TextComponent</tt>.
* This method has no effect if the text is not selectable.
* @param selectionStart the beginning of the selection range
* @param selectionEnd the end of the selection range
*/
public void select(int selectionStart, int selectionEnd) {
int length = getTextLength();
selectionStart = pin(selectionStart, 0, length);
selectionEnd = pin(selectionEnd, selectionStart, length);
TextRange range = new TextRange(selectionStart, selectionEnd);
fTextComponent.textControlEventOccurred(Behavior.SELECT, range);
}
/**
* Select all of the text in the document. This method has no effect if
* the text is not selectable.
*/
public void selectAll() {
select(0, getTextLength());
}
//============
// Format Width
//============
/**
* Return the total format width, in pixels. The format width is the
* width to which text is wrapped.
* @return the format width
*/
public int getFormatWidth() {
return fTextComponent.getFormatWidth();
}
/**
* Return true if the paragraph at the given offset is left-to-right.
* @param offset an offset in the text
* @return true if the paragraph at the given offset is left-to-right
*/
public boolean paragraphIsLeftToRight(int offset) {
return fTextComponent.paragraphIsLeftToRight(offset);
}
/**
* Return true if there is a change which can be undone.
* @return true if there is a change which can be undone.
*/
public boolean canUndo() {
if (fEditBehavior != null) {
return fEditBehavior.canUndo();
}
else {
return false;
}
}
/**
* Return true if there is a change which can be redone.
* @return true if there is a change which can be redone.
*/
public boolean canRedo() {
if (fEditBehavior != null) {
return fEditBehavior.canRedo();
}
else {
return false;
}
}
/**
* Return true if the clipboard contains contents which could be
* transfered into the text.
* @return true if the clipboard has text content.
*/
public boolean clipboardNotEmpty() {
return fTextComponent.getClipboard().hasContents();
}
/**
* Return an AttributeMap of keys with default values. The default
* values are used when displaying text for values which are not
* specified in the text.
* @return an AttributeMap of default key-value pairs
*/
public AttributeMap getDefaultValues() {
return fTextComponent.getDefaultValues();
}
private static boolean objectsAreEqual(Object lhs, Object rhs) {
if (lhs == null) {
return rhs == null;
}
else {
return lhs.equals(rhs);
}
}
private static Object consistentCharStyle(MConstText text,
int start,
int limit,
Object key,
Object defaultValue) {
if (start >= limit) {
throw new IllegalArgumentException("Invalid range.");
}
int runStart = start;
Object initialValue = text.characterStyleAt(runStart).get(key);
if (initialValue == null) {
initialValue = defaultValue;
}
for (runStart = text.characterStyleLimit(runStart);
runStart < limit;
runStart = text.characterStyleLimit(runStart)) {
Object nextValue = text.characterStyleAt(runStart).get(key);
if (nextValue == null) {
nextValue = defaultValue;
}
if (!objectsAreEqual(initialValue, nextValue)) {
return MTextPanel.MULTIPLE_VALUES;
}
}
return initialValue;
}
/**
* This method inspects the character style runs in the selection
* range (or the typing style at the insertion point) and returns:
* <ul>
* <li>The value of <tt>key</tt>, if the value of <tt>key</tt>
* is the same in all of the style runs in the selection, or</li>
* <li>null, if two or more style runs have different values for <tt>key</tt>.</li>
* </ul>
* If a style run does not contain <tt>key</tt>,
* its value is considered to be <tt>defaultStyle</tt>.
* This method is useful for configuring style menus.
* @param key the key used to retrieve values for comparison
* @param defaultValue the implicit value of <tt>key</tt> in
* style runs where <tt>key</tt> is not defined
*/
public Object getCharacterStyleOverSelection(Object key) {
TextRange selRange;
if (fSelection != null)
selRange = fSelection.getSelectionRange();
else
selRange = new TextRange(0, 0);
if (selRange.start == selRange.limit) {
AttributeMap compStyle;
if (fEditBehavior != null) {
compStyle = fEditBehavior.getInsertionPointStyle();
}
else {
compStyle = TextEditBehavior.typingStyleAt(fText, selRange.start, selRange.limit);
}
Object value = compStyle.get(key);
return value==null? getDefaultValues().get(key) : value;
}
else {
return consistentCharStyle(fText,
selRange.start,
selRange.limit,
key,
getDefaultValues().get(key));
}
}
/**
* This method inspects the paragraph style runs in the selection
* range (or the typing style at the insertion point) and returns:
* <ul>
* <li>The value of <tt>key</tt>, if the value of <tt>key</tt>
* is the same in all of the style runs in the selection, or</li>
* <li>null, if two or more style runs have different values for <tt>key</tt>.</li>
* </ul>
* If a style run does not contain <tt>key</tt>,
* its value is considered to be <tt>defaultStyle</tt>.
* This method is useful for configuring style menus.
* @param key the key used to retrieve values for comparison
* @param defaultValue the implicit value of <tt>key</tt> in
* style runs where <tt>key</tt> is not defined
*/
public Object getParagraphStyleOverSelection(Object key) {
TextRange selRange;
if (fSelection != null) {
selRange = fSelection.getSelectionRange();
}
else {
selRange = new TextRange(0, 0);
}
if (selRange.start == selRange.limit) {
AttributeMap pStyle = fText.paragraphStyleAt(selRange.start);
Object value = pStyle.get(key);
return value==null? getDefaultValues().get(key) : value;
}
else {
int paragraphStart = selRange.start;
Object defaultValue = getDefaultValues().get(key);
Object initialValue = fText.paragraphStyleAt(paragraphStart).get(key);
if (initialValue == null) {
initialValue = defaultValue;
}
for (paragraphStart = fText.paragraphLimit(paragraphStart);
paragraphStart < selRange.limit;
paragraphStart = fText.paragraphLimit(paragraphStart)) {
Object nextValue = fText.paragraphStyleAt(paragraphStart).get(key);
if (nextValue == null) {
nextValue = defaultValue;
}
if (!objectsAreEqual(initialValue, nextValue)) {
return MTextPanel.MULTIPLE_VALUES;
}
}
return initialValue;
}
}
/**
* Remove the selected text from the document and place it
* on the clipboard. This method has no effect if the text
* is not editable, or if no text is selected.
*/
public void cut() {
fTextComponent.textControlEventOccurred(Behavior.CUT, null);
}
/**
* Place the selected text on the clipboard. This method has
* no effect if no text is selected.
*/
public void copy() {
fTextComponent.textControlEventOccurred(Behavior.COPY, null);
}
/**
* Replace the currently selected text with the text on the clipboard.
* This method has no effect if the text is not editable, or if no
* text is on the clipboard.
*/
public void paste() {
fTextComponent.textControlEventOccurred(Behavior.PASTE, null);
}
/**
* Remove selected text from the document, without altering the clipboard.
* This method has no effect if the
* text is not editable.
*/
public void clear() {
fTextComponent.textControlEventOccurred(Behavior.CLEAR, null);
}
/**
* Undo the most recent text change. This method has no effect if
* there is no change to undo.
*/
public void undo() {
fTextComponent.textControlEventOccurred(Behavior.UNDO, null);
}
/**
* Redo the most recent text change. This method has no effect if
* there is no change to redo.
*/
public void redo() {
fTextComponent.textControlEventOccurred(Behavior.REDO, null);
}
/**
* Return the number of commands the command log can hold.
* @return the number of commands the command log can hold
*/
public int getCommandLogSize() {
if (fEditBehavior != null) {
return fEditBehavior.getCommandLogSize();
}
else {
return 0;
}
}
/**
* Set the number of commands the command log can hold. All
* redoable commands are removed when this method is called.
* @param size the number of commands kept in the command log
*/
public void setCommandLogSize(int size) {
fTextComponent.textControlEventOccurred(Behavior.SET_COMMAND_LOG_SIZE,
new Integer(size));
}
/**
* Remove all commands from the command log.
*/
public void clearCommandLog() {
fTextComponent.textControlEventOccurred(Behavior.CLEAR_COMMAND_LOG, null);
}
/**
* Modify the character styles on the selected characters. If no characters
* are selected, modify the typing style.
* @param modifier the StyleModifier with which to modify the styles
*/
public void modifyCharacterStyleOnSelection(StyleModifier modifier) {
fTextComponent.textControlEventOccurred(Behavior.CHARACTER_STYLE_MOD, modifier);
}
/**
* Modify the paragraph styles in paragraphs containing selected characters, or
* the paragraph containing the insertion point.
* @param modifier the StyleModifier with which to modify the styles
*/
public void modifyParagraphStyleOnSelection(StyleModifier modifier) {
fTextComponent.textControlEventOccurred(Behavior.PARAGRAPH_STYLE_MOD, modifier);
}
/**
* Return the KeyRemap used to process key events.
* @return the key remap used to process key events
* @see #setKeyRemap
*/
public KeyRemap getKeyRemap() {
return fRemap;
}
/**
* Use the given KeyRemap to map key events to characters.
* Only key
* events are affected by the remap; other text entering the
* control (via the clipboard, for example) is not affected
* by the KeyRemap.
* <p>
* Do not pass <tt>null</tt> to this method to leave key
* events unmapped. Instead, use <tt>KeyRemap.getIdentityRemap()</tt>
* @param remap the KeyRemap to use for mapping key events to characters
* @exception java.lang.NullPointerException if parameter is null
* @see KeyRemap
*/
public void setKeyRemap(KeyRemap remap) {
if (remap == null) {
throw new NullPointerException("remap can't be null");
}
fRemap = remap;
if (fEditBehavior != null) {
fEditBehavior.setKeyRemap(remap);
}
fBroadcaster.textStateChanged(TextPanelEvent.KEYREMAP_CHANGED);
}
/**
* Return the modification flag of the current text change.
* @see #setModified
*/
public boolean isModified() {
if (fEditBehavior != null) {
return fEditBehavior.isModified();
}
else {
return fModified;
}
}
/**
* Set the modification flag of the current text change.
*/
public void setModified(boolean modified) {
boolean handled = fTextComponent.textControlEventOccurred(
Behavior.SET_MODIFIED,
modified? Boolean.TRUE : Boolean.FALSE);
if (!handled) {
fModified = modified;
}
}
/**
* This method is for perf-testing only!
*/
void handleKeyEvent(java.awt.event.KeyEvent keyEvent) {
Component host = fTextComponent.getHost();
if (host != null) {
host.dispatchEvent(keyEvent);
}
}
}