/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package sun.awt.X11;

import java.awt.*;

import java.awt.peer.ComponentPeer;

import java.awt.peer.TextAreaPeer;

import java.awt.event.*;

import javax.swing.event.DocumentListener;

import javax.swing.event.DocumentEvent;

import javax.swing.JTextArea;

import javax.swing.JComponent;

import javax.swing.JScrollPane;

import javax.swing.JScrollBar;

import javax.swing.plaf.ComponentUI;

import com.sun.java.swing.plaf.motif.MotifTextAreaUI;

import javax.swing.plaf.UIResource;

import javax.swing.UIDefaults;

import javax.swing.border.Border;

import javax.swing.border.EmptyBorder;

import javax.swing.border.CompoundBorder;

import javax.swing.border.AbstractBorder;

import javax.swing.JButton;

import javax.swing.JViewport;

import javax.swing.InputMap;

import javax.swing.SwingUtilities;

import javax.swing.TransferHandler;

import javax.swing.plaf.basic.BasicArrowButton;

import javax.swing.plaf.basic.BasicScrollBarUI;

import javax.swing.plaf.basic.BasicScrollPaneUI;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import javax.swing.text.Caret;

import javax.swing.text.DefaultCaret;

import javax.swing.text.JTextComponent;

import javax.swing.plaf.BorderUIResource;

import java.awt.im.InputMethodRequests;

import sun.awt.CausedFocusEvent;

import sun.awt.AWTAccessor;

import sun.awt.SunToolkit;

class XTextAreaPeer extends XComponentPeer implements TextAreaPeer {

    boolean editable;

    AWTTextPane textPane;

    AWTTextArea jtext;

    boolean firstChangeSkipped;

    private final JavaMouseEventHandler javaMouseEventHandler

        = new JavaMouseEventHandler( this );

    /* FIXME  */

    public long filterEvents(long mask) {

        Thread.dumpStack();

        return 0;

    }

    /* FIXME   */

    public Rectangle getCharacterBounds(int i) {

        Thread.dumpStack();

        return null;

    }

    public int getIndexAtPoint(int x, int y) {

        Thread.dumpStack();

        return 0;

    }

    /**

     * Create a Text area.

     */

    XTextAreaPeer(TextArea target) {

        super( target  );

        // some initializations require that target be set even

        // though init(target) has not been called

        this.target = target;

        //ComponentAccessor.enableEvents(target,AWTEvent.MOUSE_WHEEL_EVENT_MASK);

        target.enableInputMethods(true);

        firstChangeSkipped = false;

        String text = ((TextArea)target).getText();

        jtext = new AWTTextArea(text, this);

        jtext.setWrapStyleWord(true);

        jtext.getDocument().addDocumentListener(jtext);

        XToolkit.specialPeerMap.put(jtext,this);

        jtext.enableInputMethods(true);

        textPane = new AWTTextPane(jtext,this, target.getParent());

        setBounds(x, y, width, height, SET_BOUNDS);

        textPane.setVisible(true);

        textPane.validate();

        AWTAccessor.ComponentAccessor compAccessor = AWTAccessor.getComponentAccessor();

        foreground = compAccessor.getForeground(target);

        if (foreground == null)  {

            foreground = SystemColor.textText;

        }

        setForeground(foreground);

        background = compAccessor.getBackground(target);

        if (background == null) {

            if (target.isEditable()) background = SystemColor.text;

            else background = SystemColor.control;

        }

        setBackground(background);

        if (!target.isBackgroundSet()) {

            // This is a way to set the background color of the TextArea

            // without calling setBackground - go through accessor

            compAccessor.setBackground(target, background);

        }

        if (!target.isForegroundSet()) {

            target.setForeground(SystemColor.textText);

        }

        setFont(font);

        int start = target.getSelectionStart();

        int end = target.getSelectionEnd();

        if (end > start) {

            select(start, end);

        }

        // Fix for 5100200

        // Restoring Motif behaviour

        // Since the end position of the selected text can be greater then the length of the text,

        // so we should set caret to max position of the text

        int caretPosition = Math.min(end, text.length());

        setCaretPosition(caretPosition);

        setEditable(target.isEditable());

        setScrollBarVisibility();

        // set the text of this object to the text of its target

        setTextImpl(target.getText());  //?? should this be setText

        // After this line we should not change the component's text

        firstChangeSkipped = true;

    }

    public void dispose() {

        XToolkit.specialPeerMap.remove(jtext);

        jtext.removeNotify();

        textPane.removeNotify();

        super.dispose();

    }

    /*

     * The method overrides one from XComponentPeer

     * If ignoreSubComponents=={@code true} it calls super.

     * If ignoreSubComponents=={@code false} it uses the XTextArea machinery

     * to change cursor appropriately. In particular it changes the cursor to

     * default if over scrollbars.

     */

    @Override

    public void pSetCursor(Cursor cursor, boolean ignoreSubComponents) {

        Point onScreen = getLocationOnScreen();

        if (ignoreSubComponents ||

            javaMouseEventHandler == null ||

            onScreen == null)

        {

            super.pSetCursor(cursor, true);

            return;

        }

        Point cursorPos = new Point();

        ((XGlobalCursorManager)XGlobalCursorManager.getCursorManager()).getCursorPos(cursorPos);

        Point localPoint = new Point(cursorPos.x - onScreen.x, cursorPos.y - onScreen.y );

        javaMouseEventHandler.setPointerToUnderPoint(localPoint);

        javaMouseEventHandler.setCursor();

    }

    void setScrollBarVisibility() {

        int visibility = ((TextArea)target).getScrollbarVisibility();

        jtext.setLineWrap(false);

        if (visibility == TextArea.SCROLLBARS_NONE) {

            textPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);

            textPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_NEVER);

            jtext.setLineWrap(true);

        }

        else if (visibility == TextArea.SCROLLBARS_BOTH) {

            textPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);

            textPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);

        }

        else if (visibility == TextArea.SCROLLBARS_VERTICAL_ONLY) {

            textPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);

            textPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);

            jtext.setLineWrap(true);

        }

        else if (visibility == TextArea.SCROLLBARS_HORIZONTAL_ONLY) {

            textPane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_NEVER);

            textPane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);

        }

    }

    /**

     * Compute minimum size.

     */

    public Dimension getMinimumSize() {

        return getMinimumSize(10, 60);

    }

    public Dimension getPreferredSize(int rows, int cols) {

        return getMinimumSize(rows, cols);

    }

    /**

     * @see java.awt.peer.TextAreaPeer

     */

    public Dimension getMinimumSize(int rows, int cols) {

        /*    Dimension d = null;

              if (jtext != null) {

              d = jtext.getMinimumSize(rows,cols);

              }

              return d;

        */

        int vsbwidth=0;

        int hsbheight=0;

        JScrollBar vsb = textPane.getVerticalScrollBar();

        if (vsb != null) {

            vsbwidth = vsb.getMinimumSize().width;

        }

        JScrollBar hsb = textPane.getHorizontalScrollBar();

        if (hsb != null) {

            hsbheight = hsb.getMinimumSize().height;

        }

        Font f = jtext.getFont();

        FontMetrics fm = jtext.getFontMetrics(f);

        return new Dimension(fm.charWidth('0') * cols + /*2*XMARGIN +*/ vsbwidth,

                             fm.getHeight() * rows + /*2*YMARGIN +*/ hsbheight);

    }

    public boolean isFocusable() {

        return true;

    }

    public void setVisible(boolean b) {

        super.setVisible(b);

        if (textPane != null)

            textPane.setVisible(b);

    }

    void repaintText() {

        jtext.repaintNow();

    }

    public void focusGained(FocusEvent e) {

        super.focusGained(e);

        jtext.forwardFocusGained(e);

    }

    public void focusLost(FocusEvent e) {

        super.focusLost(e);

        jtext.forwardFocusLost(e);

    }

    /**

     * Paint the component

     * this method is called when the repaint instruction has been used

     */

    public void repaint() {

        if (textPane  != null)  {

            //textPane.validate();

            textPane.repaint();

        }

    }

    public void paint(Graphics g) {

        if (textPane  != null)  {

            textPane.paint(g);

        }

    }

    public void setBounds(int x, int y, int width, int height, int op) {

        super.setBounds(x, y, width, height, op);

        if (textPane != null) {

            /*

             * Fixed 6277332, 6198290:

             * the coordinates is coming (to peer): relatively to closest HW parent

             * the coordinates is setting (to textPane): relatively to closest ANY parent

             * the parent of peer is target.getParent()

             * the parent of textPane is the same

             * see 6277332, 6198290 for more information

             */

            int childX = x;

            int childY = y;

            Component parent = target.getParent();

            // we up to heavyweight parent in order to be sure

            // that the coordinates of the text pane is relatively to closest parent

            while (parent.isLightweight()){

                childX -= parent.getX();

                childY -= parent.getY();

                parent = parent.getParent();

            }

            textPane.setBounds(childX,childY,width,height);

            textPane.validate();

        }

    }

    void handleJavaKeyEvent(KeyEvent e) {

        AWTAccessor.getComponentAccessor().processEvent(jtext,e);

    }

    public boolean handlesWheelScrolling() { return true; }

    void handleJavaMouseWheelEvent(MouseWheelEvent e) {

        AWTAccessor.getComponentAccessor().processEvent(textPane,e);

    }

    public void handleJavaMouseEvent( MouseEvent e ) {

        super.handleJavaMouseEvent( e );

        javaMouseEventHandler.handle( e );

    }

    void handleJavaInputMethodEvent(InputMethodEvent e) {

        if (jtext != null)

            jtext.processInputMethodEventPublic((InputMethodEvent)e);

    }

    /**

     * @see java.awt.peer.TextComponentPeer

     */

    public void select(int s, int e) {

        jtext.select(s,e);

        // Fixed 5100806

        // We must take care that Swing components repainted correctly

        jtext.repaint();

    }

    public void setBackground(Color c) {

        super.setBackground(c);

//          synchronized (getStateLock()) {

//              background = c;

//          }

        if (jtext != null) {

            jtext.setBackground(c);

            jtext.setSelectedTextColor(c);

        }

//          repaintText();

    }

    public void setForeground(Color c) {

        super.setForeground(c);

//          synchronized (getStateLock()) {

//              foreground = c;

//          }

        if (jtext != null) {

            jtext.setForeground(foreground);

            jtext.setSelectionColor(foreground);

            jtext.setCaretColor(foreground);

        }

//          repaintText();

    }

    public void setFont(Font f) {

        super.setFont(f);

//          synchronized (getStateLock()) {

//              font = f;

//          }

        if (jtext != null) {

            jtext.setFont(font);

        }

        textPane.validate();

    }

    /**

     * @see java.awt.peer.TextComponentPeer

     */

    public void setEditable(boolean editable) {

        this.editable = editable;

        if (jtext != null) jtext.setEditable(editable);

        repaintText();

    }

    /**

     * @see java.awt.peer.ComponentPeer

     */

    public void setEnabled(boolean enabled) {

        super.setEnabled(enabled);

        if (jtext != null) {

            jtext.setEnabled(enabled);

            jtext.repaint();

        }

    }

    /**

     * @see java.awt.peer.TextComponentPeer

     */

    public InputMethodRequests getInputMethodRequests() {

        if (jtext != null) return jtext.getInputMethodRequests();

        else  return null;

    }

    /**

     * @see java.awt.peer.TextComponentPeer

     */

    public int getSelectionStart() {

        return jtext.getSelectionStart();

    }

    /**

     * @see java.awt.peer.TextComponentPeer

     */

    public int getSelectionEnd() {

        return jtext.getSelectionEnd();

    }

    /**

     * @see java.awt.peer.TextComponentPeer

     */

    public String getText() {

        return jtext.getText();

    }

    /**

     * @see java.awt.peer.TextComponentPeer

     */

    public void setText(String txt) {

        setTextImpl(txt);

        repaintText();

    }

    protected boolean setTextImpl(String txt) {

        if (jtext != null) {

            // Please note that we do not want to post an event

            // if setText() replaces an empty text by an empty text,

            // that is, if component's text remains unchanged.

            if (jtext.getDocument().getLength() == 0 && txt.length() == 0) {

                return true;

            }

            // JTextArea.setText() posts two different events (remove & insert).

            // Since we make no differences between text events,

            // the document listener has to be disabled while

            // JTextArea.setText() is called.

            jtext.getDocument().removeDocumentListener(jtext);

            jtext.setText(txt);

            if (firstChangeSkipped) {

                postEvent(new TextEvent(target, TextEvent.TEXT_VALUE_CHANGED));

            }

            jtext.getDocument().addDocumentListener(jtext);

        }

        return true;

    }

    /**

     * insert the text "txt on position "pos" in the array lines

     * @see java.awt.peer.TextAreaPeer

     */

    public void insert(String txt, int p) {

        if (jtext != null) {

            boolean doScroll = (p >= jtext.getDocument().getLength() && jtext.getDocument().getLength() != 0);

            jtext.insert(txt,p);

            textPane.validate();

            if (doScroll) {

                JScrollBar bar = textPane.getVerticalScrollBar();

                if (bar != null) {

                    bar.setValue(bar.getMaximum()-bar.getVisibleAmount());

                }

            }

        }

    }

    /**

     * replace the text between the position "s" and "e" with "txt"

     * @see java.awt.peer.TextAreaPeer

     */

    public void replaceRange(String txt, int s, int e) {

        if (jtext != null) {

            // JTextArea.replaceRange() posts two different events.

            // Since we make no differences between text events,

            // the document listener has to be disabled while

            // JTextArea.replaceRange() is called.

            jtext.getDocument().removeDocumentListener(jtext);

            jtext.replaceRange(txt, s, e);

            postEvent(new TextEvent(target, TextEvent.TEXT_VALUE_CHANGED));

            jtext.getDocument().addDocumentListener(jtext);

        }

    }