/*
 * @(#)ActiveClient.java	1.2 99/08/02
 * 
 * Copyright 1997-1999 by Sun Microsystems, Inc.,
 * 901 San Antonio Road, Palo Alto, California, 94303, U.S.A.
 * All rights reserved.
 */

import java.awt.Component;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.event.InputMethodEvent;
import java.awt.event.InputMethodListener;
import java.awt.im.InputMethodRequests;
import java.awt.font.TextAttribute;
import java.awt.font.TextHitInfo;
import java.awt.font.TextLayout;
import java.text.AttributedCharacterIterator;
import java.text.AttributedCharacterIterator.Attribute;
import java.text.AttributedString;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;


/**
 * Implements an integrated text input user interface.
 * This class is an active client of the input method framework, that is,
 * actively uses its APIs to accomplish integration.
 * <p>
 * This class directly implements the two client interfaces of the input method
 * framework, InputMethodListener and InputMethodRequests.
 * This is not required. Especially in cases where the public
 * interface matters (such as in a class library), it may be more
 * appropriate to hide the implementations of these two interfaces
 * in separate classes.
 * 
 */

public class ActiveClient extends LWTextComponent
        implements InputMethodListener, InputMethodRequests {

    // the composed text received from the input method
    // with font information added so we can easily create a TextLayout
    private AttributedString composedTextString = null;
    private AttributedCharacterIterator composedText = null;

    // the caret received from the input method; relative  to composed text
    private TextHitInfo caret = null;

    /**
     * Constructs an ActiveClient. Input methods are always enabled for
     * ActiveClient instances.
     * @param name the component name to be displayed above the text
     */
    public ActiveClient(String name) {
        super(name, true);
        enableInputMethods(true);
	addInputMethodListener(this);
    }
    
    /**
     * Implements getInputMethodRequests for ActiveClient by returning "this".
     * @return "this"
     */
    public InputMethodRequests getInputMethodRequests() {
        return this;
    }
    
    /**
     * Adjusts composed text for new font size.
     */
    public void setFontSize(int size) {
        super.setFontSize(size);
        if (composedTextString != null) {
            composedTextString.addAttribute(TextAttribute.FONT, getFont());
        }
    }

    /**
     * Returns the text that the user has entered.
     * This override returns the concatenation of committed text
     * and composed text.
     */
    public AttributedCharacterIterator getDisplayText() {
        if (composedText == null) {
            return super.getDisplayText();
        } else {
            // We don't want to copy all the text and attribute data here.
            // Instead, we return a CompositeIterator which iterates over
            // the concatenation of two iterators.
            return new CompositeIterator(super.getDisplayText(), composedText);
        }
    }
    
    /**
     * Returns a text hit info indicating the current caret (insertion point).
     * This override returns the caret provided by the input method while
     * there is composed text; otherwise it returns a caret at the end
     * of the committed text. The caret provided by the input method may be null.
     */
    public TextHitInfo getCaret() {
        if (composedText == null) {
            return super.getCaret();
        } else if (caret == null) {
            return null;
        } else {
            // the caret provided by the input method is relative
            // to the composed text, so translate it to the entire text
            return caret.getOffsetHit(getCommittedTextLength());
        }
    }

    // InputMethodListener implementation

    // constant attribute set for use when copying composed text
    private static final Attribute[] IM_ATTRIBUTES =
            { TextAttribute.INPUT_METHOD_HIGHLIGHT };

    /**
     * Handles changes to the text entered through an input method.
     * Committed text contained in the event is appended to the
     * committed text of the text component. Composed text contained
     * in the event replaces any existing composed text in the text
     * component.
     * The caret defined in the event is saved and will
     * be returned by getCaret if there is composed text. The
     * component is redrawn.
     * <p>
     * In this simple component, we only
     * keep input method highlight attributes. Smarter components may want to
     * keep language, reading, input method segment, and other
     * attributes as well.
     */
    public void inputMethodTextChanged(InputMethodEvent event) {
        int committedCharacterCount = event.getCommittedCharacterCount();
        AttributedCharacterIterator text = event.getText();
        composedText = null;
        char c;
        if (text != null) {
            // copy the committed text
            int toCopy = committedCharacterCount;
            c = text.first();
            while (toCopy-- > 0) {
                insertCharacter(c);
                c = text.next();
            }

            // copy the composed text
            if (text.getEndIndex() - (text.getBeginIndex() + committedCharacterCount) > 0) {
                composedTextString = new AttributedString(text,
                        text.getBeginIndex() + committedCharacterCount, // skip over committed text
                        text.getEndIndex(), IM_ATTRIBUTES);
                // add font information because TextLayout requires it
                composedTextString.addAttribute(TextAttribute.FONT, getFont());
                composedText = composedTextString.getIterator();
            }
        }
	event.consume();
	invalidateTextLayout();
	caret = event.getCaret();
	repaint();
    }

    /**
     * Handles changes to the caret within composed text.
     * The caret defined in the event is saved and will
     * be returned by getCaret if there is composed text. The
     * component is redrawn.
     */
    public void caretPositionChanged(InputMethodEvent event) {
	caret = event.getCaret();
	event.consume();
	repaint();
    }

    // InputMethodRequests implementation
    // Note that getCommittedTextLength is already implemented in LWTextComponent

    /**
     * Gets the location of a specified offset in the current composed text,
     * or of the selection in committed text.
     */
    public Rectangle getTextLocation(TextHitInfo offset) {

        // determine the text location in component coordinates
        Rectangle rectangle;
        if (offset == null) {
            // no composed text: return caret for committed text
            rectangle = getCaretRectangle();
        } else {
            // composed text: return caret within composed text
            TextHitInfo globalOffset = offset.getOffsetHit(getCommittedTextLength());
            rectangle = getCaretRectangle(globalOffset);
        }

        // translate to screen coordinates
        Point location = getLocationOnScreen();
        rectangle.translate(location.x, location.y);

	return rectangle;
    }

    /**
     * Gets the offset within the composed text for the specified absolute x
     * and y coordinates on the screen.
     */
    public TextHitInfo getLocationOffset(int x, int y) {

        // translate from screen coordinates to coordinates in the text layout
        Point location = getLocationOnScreen();
        Point textOrigin = getTextOrigin();
        x -= location.x + textOrigin.x;
        y -= location.y + textOrigin.y;
        
        // TextLayout maps locations far outside its bounds to locations within.
        // To avoid false hits, we use it only if it actually contains the location.
        // We also have to translate the TextHitInfo to be relative to composed text.
        TextLayout textLayout = getTextLayout();
        if (textLayout != null &&
                textLayout.getBounds().contains(x, y)) {
            return textLayout.hitTestChar(x, y).getOffsetHit(-getCommittedTextLength());
        } else {
            return null;
        }
    }

    /**
     * Gets the offset of the insert position in the committed text contained
     * in the text editing component. In this simple component, that's always
     * at the end of the committed text.
     */
    public int getInsertPositionOffset() {
        return getCommittedTextLength();
    }

    /**
     * Gets an iterator providing access to the entire text and attributes
     * contained in the text editing component except for uncommitted
     * text.
     */
    public AttributedCharacterIterator getCommittedText(int beginIndex,
    		int endIndex, Attribute[] attributes) {
        return getCommittedText(beginIndex, endIndex);
    }

    /**
     * Returns null to indicate that the "Undo Commit" feature is not supported
     * by this simple text component.
     */
    public AttributedCharacterIterator cancelLatestCommittedText(Attribute[] attributes) {
        return null;
    }

    private static final AttributedCharacterIterator EMPTY_TEXT =
            (new AttributedString("")).getIterator();

    /**
     * Gets the currently selected text from the text editing component.
     * Since this simple text component doesn't support selections, this is
     * always an iterator over empty text.
     */
    public AttributedCharacterIterator getSelectedText(Attribute[] attributes) {
        return EMPTY_TEXT;
    }
}

/**
 * Iterates over the combined text of two AttributedCharacterIterators.
 * Assumes that no annotation spans the two iterators.
 */

class CompositeIterator implements AttributedCharacterIterator {

    AttributedCharacterIterator iterator1;
    AttributedCharacterIterator iterator2;
    int begin1, end1;
    int begin2, end2;
    int endIndex;
    int currentIndex;
    AttributedCharacterIterator currentIterator;
    int currentIteratorDelta;
    
    /**
     * Constructs a CompositeIterator that iterates over the concatenation
     * of iterator1 and iterator2.
     * @param iterator1, iterator2 the base iterators that this composite iterator concatenates
     */
    CompositeIterator(AttributedCharacterIterator iterator1, AttributedCharacterIterator iterator2) {
        this.iterator1 = iterator1;
        this.iterator2 = iterator2;
        begin1 = iterator1.getBeginIndex();
        end1 = iterator1.getEndIndex();
        begin2 = iterator2.getBeginIndex();
        end2 = iterator2.getEndIndex();
        endIndex = (end1 - begin1) + (end2 - begin2);
        internalSetIndex(0);
    }
    
    // CharacterIterator implementation
    
    public char first() {
        return internalSetIndex(0);
    }
    
    public char last() {
        if (endIndex == 0) {
            return internalSetIndex(endIndex);
        } else {
            return internalSetIndex(endIndex - 1);
        }
    }
    
    public char next() {
        if (currentIndex < endIndex) {
            return internalSetIndex(currentIndex + 1);
        } else {
            return DONE;
        }
    }
    
    public char previous() {
        if (currentIndex > 0) {
            return internalSetIndex(currentIndex - 1);
        } else {
            return DONE;
        }
    }
    
    public char current() {
        return currentIterator.setIndex(currentIndex + currentIteratorDelta);
    }
    
    public char setIndex(int position) {
        if (position < 0 || position > endIndex) {
            throw new IllegalArgumentException("invalid index");
        }
        return internalSetIndex(position);
    }
    
    private char internalSetIndex(int position) {
        currentIndex = position;
        if (currentIndex < end1 - begin1) {
            currentIterator = iterator1;
            currentIteratorDelta = begin1;
        } else {
            currentIterator = iterator2;
            currentIteratorDelta = begin2 - (end1 - begin1);
        }
        return currentIterator.setIndex(currentIndex + currentIteratorDelta);
    }
    
    public int getBeginIndex() {
        return 0;
    }
    
    public int getEndIndex() {
        return endIndex;
    }
    
    public int getIndex() {
        return currentIndex;
    }
    
    // AttributedCharacterIterator implementation
    
    public int getRunStart() {
        return currentIterator.getRunStart() - currentIteratorDelta;
    }
    
    public int getRunLimit() {
        return currentIterator.getRunLimit() - currentIteratorDelta;
    }
    
    public int getRunStart(Attribute attribute) {
        return currentIterator.getRunStart(attribute) - currentIteratorDelta;
    }
    
    public int getRunLimit(Attribute attribute) {
        return currentIterator.getRunLimit(attribute) - currentIteratorDelta;
    }

    public int getRunStart(Set attributes) {
        return currentIterator.getRunStart(attributes) - currentIteratorDelta;
    }
    
    public int getRunLimit(Set attributes) {
        return currentIterator.getRunLimit(attributes) - currentIteratorDelta;
    }
    
    public Map getAttributes() {
        return currentIterator.getAttributes();
    }
    
    public Set getAllAttributeKeys() {
        Set keys = new HashSet(iterator1.getAllAttributeKeys());
        keys.addAll(iterator2.getAllAttributeKeys());
        return keys;
    }
    
    public Object getAttribute(Attribute attribute) {
        return currentIterator.getAttribute(attribute);
    }
    
    // Object overrides

    public Object clone() {
        try {
            CompositeIterator other = (CompositeIterator) super.clone();
            return other;
        } catch (CloneNotSupportedException e) {
            throw new InternalError();
        }
    }
}