/*
* (C) Copyright IBM Corp. 1998-2008. 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.
*/
/*
2/25/99 - Now processing characters from keyTyped method (not keyPressed).
This new way is input-method friendly on 1.2, and is generally
more correct.
7/7/97 - the mouseDidSomething methods used to remove the typing interactor.
This is definitely wrong, but maybe that made sense at one time. Anyway,
now the mousePressed / mouseReleased methods remove the interactor; the
others do nothing.
*/
package com.ibm.richtext.textpanel;
import com.ibm.richtext.textlayout.attributes.AttributeMap;
import java.awt.event.KeyEvent;
import java.awt.event.MouseEvent;
import java.awt.event.FocusEvent;
import java.text.BreakIterator;
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;
final class TypingInteractor extends Behavior {
// static final String COPYRIGHT =
// "(C) Copyright IBM Corp. 1998-1999 - All Rights Reserved";
private static final char BACKSPACE = 8;
private static final char TAB = '\t';
private static final char RETURN = '\r';
private static final char LINE_FEED = '\n';
// private static final char PARAGRAPH_SEP = '\u2029';
// private TextComponent fTextComponent;
private TextSelection fSelection;
private AttributeMap fTypingStyle;
private MConstText fText;
private TextEditBehavior fParent;
private TextChangeCommand fCommand = null;
private SimpleCommandLog fCommandLog;
private PanelEventBroadcaster fListener;
private BreakIterator fCharBreak = null;
/**
* Not all characters that come from the keyboard are handled
* as input. For example, ctrl-c is not a typable character.
* This method determines whether a particular character from
* the keyboard will affect the text.
*/
private static boolean isTypingInteractorChar(char ch) {
return ch >= ' ' ||
ch == LINE_FEED ||
ch == RETURN ||
ch == TAB ||
ch == BACKSPACE;
}
/**
* This method determines whether a TypingInteractor should
* handle the given KeyEvent.
*/
static boolean handledByTypingInteractor(KeyEvent event) {
final int id = event.getID();
if (id == KeyEvent.KEY_TYPED) {
return isTypingInteractorChar(event.getKeyChar());
}
else {
return (id == KeyEvent.KEY_PRESSED &&
event.getKeyCode() == KeyEvent.VK_DELETE);
}
}
public TypingInteractor(TextComponent textComponent,
TextSelection selection,
AttributeMap typingStyle,
TextEditBehavior parent,
SimpleCommandLog commandLog,
PanelEventBroadcaster listener) {
// fTextComponent = textComponent;
fText = textComponent.getText();
fSelection = selection;
fTypingStyle = typingStyle;
fParent = parent;
fCommandLog = commandLog;
fListener = listener;
fParent.setTypingInteractor(this);
}
private void endInteraction() {
removeFromOwner();
postTextChangeCommand();
int selStart = fSelection.getStart().fOffset;
int selLimit = fSelection.getEnd().fOffset;
fParent.setSavedTypingStyle(selStart==selLimit? fTypingStyle : null, selStart);
fParent.setTypingInteractor(null);
}
public boolean textControlEventOccurred(Behavior.EventType event, Object what) {
if (fCommand == null && event == Behavior.CHARACTER_STYLE_MOD) {
pickUpTypingStyle();
fTypingStyle = ((StyleModifier)what).modifyStyle(fTypingStyle);
fListener.textStateChanged(TextPanelEvent.SELECTION_STYLES_CHANGED);
return true;
}
else {
Behavior next = nextBehavior(); // save because removeFromOwner() will trash this
endInteraction();
if (next != null)
return next.textControlEventOccurred(event, what);
else
return false;
}
}
private void doBackspace() {
int selStart = fSelection.getStart().fOffset;
int selLimit = fSelection.getEnd().fOffset;
if (selStart == selLimit) {
if (selStart != 0) {
fTypingStyle = null;
pickUpTypingStyle();
makeTextChangeCommand();
if (selStart <= fCommand.affectedRangeStart()) {
fCommand.prependToOldText(fText.extract(selStart - 1, selStart));
}
TextOffset insPt = new TextOffset(selStart - 1);
fParent.doReplaceText(selStart - 1, selStart, null, insPt, insPt);
}
}
else {
fTypingStyle = null;
makeTextChangeCommand();
TextOffset insPt = new TextOffset(selStart);
fParent.doReplaceText(selStart, selLimit, null, insPt, insPt);
}
}
private void doFwdDelete(boolean ignoreCharBreak) {
int selStart = fSelection.getStart().fOffset;
int selLimit = fSelection.getEnd().fOffset;
TextOffset insPt = new TextOffset(selStart);
if (selStart == selLimit) {
if (selStart != fText.length()) {
fTypingStyle = null;
makeTextChangeCommand();
int numChars;
if (ignoreCharBreak) {
numChars = 1;
}
else {
if (fCharBreak == null) {
fCharBreak = BreakIterator.getCharacterInstance();
}
fCharBreak.setText(fText.createCharacterIterator());
numChars = fCharBreak.following(selStart) - selStart;
}
fCommand.appendToOldText(fText.extract(selStart, selStart + numChars));
fParent.doReplaceText(selStart, selStart + numChars, null, insPt, insPt);
}
}
else {
fTypingStyle = null;
makeTextChangeCommand();
fParent.doReplaceText(selStart, selLimit, null, insPt, insPt);
}
}
private void doNormalKey(char ch) {
// Sigh - 1.1 reports enter key events as return chars, but
// 1.2 reports them as linefeeds.
if (ch == RETURN) {
ch = LINE_FEED;
}
pickUpTypingStyle();
makeTextChangeCommand();
fParent.doReplaceSelectedText(ch, fTypingStyle);
}
public boolean focusGained(FocusEvent e) {
// pass through, but stick around...
return super.focusGained(e);
}
public boolean focusLost(FocusEvent e) {
// pass through, but stick around...
return super.focusLost(e);
}
public boolean keyTyped(KeyEvent e) {
if (e.getKeyChar() == BACKSPACE) {
doBackspace();
}
else {
if (isTypingInteractorChar(e.getKeyChar())) {
KeyRemap remap = fParent.getKeyRemap();
doNormalKey(remap.remap(e));
}
}
return true;
}
public boolean keyPressed(KeyEvent e) {
int key = e.getKeyCode();
if (key == KeyEvent.VK_DELETE) {
doFwdDelete(e.isShiftDown());
return true;
}
Behavior next = nextBehavior();
if (TextSelection.keyAffectsSelection(e)) {
endInteraction();
}
return next.keyPressed(e);
}
public boolean keyReleased(KeyEvent e) {
return true;
}
private void makeTextChangeCommand() {
if (fCommand == null) {
TextOffset selStart = fSelection.getStart();
TextOffset selEnd = fSelection.getEnd();
MText writableText = new StyledText();
writableText.replace(0, 0, fText, selStart.fOffset, selEnd.fOffset);
fCommand = new TextChangeCommand(fParent,
writableText,
null, selStart.fOffset, selStart, selEnd,
new TextOffset(), new TextOffset());
fListener.textStateChanged(TextPanelEvent.UNDO_STATE_CHANGED);
}
}
public boolean mouseDragged(MouseEvent e) {
return true;
}
public boolean mouseEntered(MouseEvent e) {
return true;
}
public boolean mouseExited(MouseEvent e) {
return true;
}
public boolean mouseMoved(MouseEvent e) {
return true;
}
public boolean mousePressed(MouseEvent e) {
Behavior next = nextBehavior(); // save because removeFromOwner() will trash this
endInteraction();
if (next != null)
return next.mousePressed(e);
else
return false;
}
public boolean mouseReleased(MouseEvent e) {
Behavior next = nextBehavior(); // save because removeFromOwner() will trash this
endInteraction();
if (next != null)
return next.mouseReleased(e);
else
return false;
}
private void pickUpTypingStyle() {
if (fTypingStyle == null) {
int selStart = fSelection.getStart().fOffset;
int selLimit = fSelection.getEnd().fOffset;
fTypingStyle = TextEditBehavior.typingStyleAt(fText, selStart, selLimit);
}
}
private void postTextChangeCommand() {
if (fCommand != null) {
TextOffset selStart = fSelection.getStart();
TextOffset selEnd = fSelection.getEnd();
fCommand.setNewText(fText.extract(fCommand.affectedRangeStart(), selStart.fOffset));
fCommand.setSelRangeAfter(selStart, selEnd);
fCommandLog.add(fCommand);
}
}
boolean hasPendingCommand() {
return fCommand != null;
}
AttributeMap getTypingStyle() {
pickUpTypingStyle();
return fTypingStyle;
}
}