| /* |
| * (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; |
| } |
| } |
