/*
 * Copyright (C) 2013 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.ide.eclipse.adt.internal.editors.draw9patch.ui;

import com.android.ide.eclipse.adt.AdtPlugin;
import com.android.ide.eclipse.adt.internal.editors.draw9patch.graphics.NinePatchedImage;
import com.android.ide.eclipse.adt.internal.editors.draw9patch.graphics.NinePatchedImage.Chunk;
import com.android.ide.eclipse.adt.internal.editors.draw9patch.graphics.NinePatchedImage.Tick;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.KeyListener;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseListener;
import org.eclipse.swt.events.MouseMoveListener;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.ScrollBar;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;

/**
 * View and edit Draw 9-patch image.
 */
public class ImageViewer extends Canvas implements PaintListener, KeyListener, MouseListener,
        MouseMoveListener {
    private static final boolean DEBUG = false;

    public static final String HELP_MESSAGE_KEY_TIPS = "Press Shift to erase pixels."
            + " Press Control to draw layout bounds.";

    public static final String HELP_MESSAGE_KEY_TIPS2 = "Release Shift to draw pixels.";

    private static final Color BLACK_COLOR = AdtPlugin.getDisplay().getSystemColor(SWT.COLOR_BLACK);
    private static final Color RED_COLOR = AdtPlugin.getDisplay().getSystemColor(SWT.COLOR_RED);

    private static final Color BACK_COLOR
            = new Color(AdtPlugin.getDisplay(), new RGB(0x00, 0xFF, 0x00));
    private static final Color LOCK_COLOR
            = new Color(AdtPlugin.getDisplay(), new RGB(0xFF, 0x00, 0x00));
    private static final Color PATCH_COLOR
            = new Color(AdtPlugin.getDisplay(), new RGB(0xFF, 0xFF, 0x00));
    private static final Color PATCH_ONEWAY_COLOR
            = new Color(AdtPlugin.getDisplay(), new RGB(0x00, 0x00, 0xFF));
    private static final Color CORRUPTED_COLOR
            = new Color(AdtPlugin.getDisplay(), new RGB(0xFF, 0x00, 0x00));

    private static final int NONE_ALPHA = 0xFF;
    private static final int LOCK_ALPHA = 50;
    private static final int PATCH_ALPHA = 50;
    private static final int GUIDE_ALPHA = 60;

    private static final int MODE_NONE = 0x00;
    private static final int MODE_BLACK_TICK = 0x01;
    private static final int MODE_RED_TICK = 0x02;
    private static final int MODE_ERASE = 0xFF;

    private int mDrawMode = MODE_NONE;

    private static final int MARGIN = 5;
    private static final String CHECKER_PNG_PATH = "/icons/checker.png";

    private Image mBackgroundLayer = null;

    private NinePatchedImage mNinePatchedImage = null;

    private Chunk[][] mChunks = null;
    private Chunk[][] mBadChunks = null;

    private boolean mIsLockShown = true;
    private boolean mIsPatchesShown = false;
    private boolean mIsBadPatchesShown = false;

    private ScrollBar mHorizontalBar;
    private ScrollBar mVerticalBar;

    private int mZoom = 500;

    private int mHorizontalScroll = 0;
    private int mVerticalScroll = 0;

    private final Rectangle mPadding = new Rectangle(0, 0, 0, 0);

    // one pixel size that considered zoom
    private int mZoomedPixelSize = 1;

    private Image mBufferImage = null;

    private boolean isCtrlPressed = false;
    private boolean isShiftPressed = false;

    private final List<UpdateListener> mUpdateListenerList
            = new ArrayList<UpdateListener>();

    private final Point mCursorPoint = new Point(0, 0);

    private static final int DEFAULT_UPDATE_QUEUE_SIZE = 10;

    private final ArrayBlockingQueue<NinePatchedImage> mUpdateQueue
            = new ArrayBlockingQueue<NinePatchedImage>(DEFAULT_UPDATE_QUEUE_SIZE);

    private final Runnable mUpdateRunnable = new Runnable() {
        @Override
        public void run() {
            if (isDisposed()) {
                return;
            }

            redraw();

            fireUpdateEvent();
        }
    };

    private final Thread mUpdateThread = new Thread() {
        @Override
        public void run() {
            while (!isDisposed()) {
                try {
                    mUpdateQueue.take();
                    mNinePatchedImage.findPatches();
                    mNinePatchedImage.findContentsArea();

                    mChunks = mNinePatchedImage.getChunks(mChunks);
                    mBadChunks = mNinePatchedImage.getCorruptedChunks(mBadChunks);

                    AdtPlugin.getDisplay().asyncExec(mUpdateRunnable);

                } catch (InterruptedException e) {
                }
            }
        }
    };

    private StatusChangedListener mStatusChangedListener = null;

    public void addUpdateListener(UpdateListener l) {
        mUpdateListenerList.add(l);
    }

    public void removeUpdateListener(UpdateListener l) {
        mUpdateListenerList.remove(l);
    }

    private void fireUpdateEvent() {
        int len = mUpdateListenerList.size();
        for(int i=0; i < len; i++) {
            mUpdateListenerList.get(i).update(mNinePatchedImage);
        }
    }

    public void setStatusChangedListener(StatusChangedListener l) {
        mStatusChangedListener = l;
        if (mStatusChangedListener != null) {
            mStatusChangedListener.helpTextChanged(HELP_MESSAGE_KEY_TIPS);
        }
    }

    void setShowLock(boolean show) {
        mIsLockShown = show;
        redraw();
    }

    void setShowPatchesArea(boolean show) {
        mIsPatchesShown = show;
        redraw();
    }

    void setShowBadPatchesArea(boolean show) {
        mIsBadPatchesShown = show;
        redraw();
    }

    void setZoom(int zoom) {
        mZoom = zoom;
        mZoomedPixelSize = getZoomedPixelSize(1);
        redraw();
    }

    public ImageViewer(Composite parent, int style) {
        super(parent, style);

        mUpdateThread.start();

        mBackgroundLayer = AdtPlugin.getImageDescriptor(CHECKER_PNG_PATH).createImage();

        addMouseListener(this);
        addMouseMoveListener(this);
        addPaintListener(this);

        mHorizontalBar = getHorizontalBar();
        mHorizontalBar.setThumb(1);
        mHorizontalBar.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent event) {
                super.widgetSelected(event);
                ScrollBar bar = (ScrollBar) event.widget;
                if (mHorizontalBar.isVisible()
                        && mHorizontalScroll != bar.getSelection()) {
                    mHorizontalScroll = bar.getSelection();
                    redraw();
                }
            }
        });

        mVerticalBar = getVerticalBar();
        mVerticalBar.setThumb(1);
        mVerticalBar.addSelectionListener(new SelectionAdapter() {
            @Override
            public void widgetSelected(SelectionEvent event) {
                super.widgetSelected(event);
                ScrollBar bar = (ScrollBar) event.widget;
                if (mVerticalBar.isVisible()
                        && mVerticalScroll != bar.getSelection()) {
                    mVerticalScroll = bar.getSelection();
                    redraw();
                }
            }
        });
    }

    /**
     * Load the image file.
     *
     * @param fileName must be absolute path
     */
    public NinePatchedImage loadFile(String fileName) {
        mNinePatchedImage = new NinePatchedImage(fileName);

        return mNinePatchedImage;
    }

    /**
     * Start displaying the image.
     */
    public void startDisplay() {
        mZoomedPixelSize = getZoomedPixelSize(1);

        scheduleUpdate();
    }

    private void draw(int x, int y, int drawMode) {
        if (drawMode == MODE_ERASE) {
            erase(x, y);
        } else {
            int color = (drawMode == MODE_RED_TICK) ? NinePatchedImage.RED_TICK
                    : NinePatchedImage.BLACK_TICK;
            mNinePatchedImage.setPatch(x, y, color);
            redraw();

            scheduleUpdate();
        }
    }

    private void erase(int x, int y) {
        mNinePatchedImage.erase(x, y);
        redraw();

        scheduleUpdate();
    }

    private void scheduleUpdate() {
        try {
            mUpdateQueue.put(mNinePatchedImage);
        } catch (InterruptedException e) {
        }
    }

    @Override
    public void mouseDown(MouseEvent event) {
        if (event.button == 1 && !isShiftPressed) {
            mDrawMode = !isCtrlPressed ? MODE_BLACK_TICK : MODE_RED_TICK;
            draw(mCursorPoint.x, mCursorPoint.y, mDrawMode);
        } else if (event.button == 3 || isShiftPressed) {
            mDrawMode = MODE_ERASE;
            erase(mCursorPoint.x, mCursorPoint.y);
        }
    }

    @Override
    public void mouseUp(MouseEvent event) {
        mDrawMode = MODE_NONE;
    }

    @Override
    public void mouseDoubleClick(MouseEvent event) {
    }

    private int getLogicalPositionX(int x) {
        return Math.round((x - mPadding.x + mHorizontalScroll) / ((float) mZoom / 100));
    }

    private int getLogicalPositionY(int y) {
        return Math.round((y - mPadding.y + mVerticalScroll) / ((float) mZoom / 100));
    }

    @Override
    public void mouseMove(MouseEvent event) {
        int posX = getLogicalPositionX(event.x);
        int posY = getLogicalPositionY(event.y);

        int width = mNinePatchedImage.getWidth();
        int height = mNinePatchedImage.getHeight();

        if (posX < 0) {
            posX = 0;
        }
        if (posX >= width) {
            posX = width - 1;
        }
        if (posY < 0) {
            posY = 0;
        }
        if (posY >= height) {
            posY = height - 1;
        }

        if (mDrawMode != MODE_NONE) {
            int drawMode = mDrawMode;
            if (isShiftPressed) {
                drawMode = MODE_ERASE;
            } else if (mDrawMode != MODE_ERASE) {
                drawMode = !isCtrlPressed ? MODE_BLACK_TICK : MODE_RED_TICK;
            }

            /*
             * Consider the previous cursor position because mouseMove events are
             * scatter.
             */
            int x = mCursorPoint.x;
            int y = mCursorPoint.y;
            for (; y != posY; y += (y > posY) ? -1 : 1) {
                draw(x, y, drawMode);
            }

            x = mCursorPoint.x;
            y = mCursorPoint.y;
            for (; x != posX; x += (x > posX) ? -1 : 1) {
                draw(x, y, drawMode);
            }
        }
        mCursorPoint.x = posX;
        mCursorPoint.y = posY;

        redraw();

        if (mStatusChangedListener != null) {
            // Update position on status panel if position is in logical size.
            if (posX >= 0 && posY >= 0
                    && posX <= mNinePatchedImage.getWidth()
                    && posY <= mNinePatchedImage.getHeight()) {
                mStatusChangedListener.cursorPositionChanged(posX + 1, posY + 1);
            }
        }
    }

    private synchronized void calcPaddings(int width, int height) {
        Point canvasSize = getSize();

        mPadding.width = getZoomedPixelSize(width);
        mPadding.height = getZoomedPixelSize(height);

        int margin = getZoomedPixelSize(MARGIN);

        if (mPadding.width < canvasSize.x) {
            mPadding.x = (canvasSize.x - mPadding.width) / 2;
        } else {
            mPadding.x = margin;
        }

        if (mPadding.height < canvasSize.y) {
            mPadding.y = (canvasSize.y - mPadding.height) / 2;
        } else {
            mPadding.y = margin;
        }
    }

    private void calcScrollBarSettings() {
        Point size = getSize();
        int screenWidth = size.x;
        int screenHeight = size.y;

        int imageWidth = getZoomedPixelSize(mNinePatchedImage.getWidth() + 1);
        int imageHeight = getZoomedPixelSize(mNinePatchedImage.getHeight() + 1);

        // consider the scroll bar sizes
        int verticalBarSize = mVerticalBar.getSize().x;
        int horizontalBarSize = mHorizontalBar.getSize().y;

        int horizontalScroll = imageWidth - (screenWidth - verticalBarSize);
        int verticalScroll = imageHeight - (screenHeight - horizontalBarSize);

        int margin = getZoomedPixelSize(MARGIN) * 2;

        if (horizontalScroll > 0) {
            mHorizontalBar.setVisible(true);

            // horizontal maximum
            int max = horizontalScroll + verticalBarSize + margin;
            mHorizontalBar.setMaximum(max);

            // set corrected scroll size
            int value = mHorizontalBar.getSelection();
            value = max < value ? max : value;

            mHorizontalBar.setSelection(value);
            mHorizontalScroll = value;

        } else {
            mHorizontalBar.setSelection(0);
            mHorizontalBar.setMaximum(0);
            mHorizontalBar.setVisible(false);
        }

        if (verticalScroll > 0) {
            mVerticalBar.setVisible(true);

            // vertical maximum
            int max = verticalScroll + horizontalBarSize + margin;
            mVerticalBar.setMaximum(max);

            // set corrected scroll size
            int value = mVerticalBar.getSelection();
            value = max < value ? max : value;

            mVerticalBar.setSelection(value);
            mVerticalScroll = value;

        } else {
            mVerticalBar.setSelection(0);
            mVerticalBar.setMaximum(0);
            mVerticalBar.setVisible(false);
        }
    }

    private int getZoomedPixelSize(int val) {
        return Math.round(val * (float) mZoom / 100);
    }

    @Override
    public void paintControl(PaintEvent pe) {
        if (mNinePatchedImage == null) {
            return;
        }

        // Use buffer
        GC bufferGc = null;
        if (mBufferImage == null) {
            mBufferImage = new Image(AdtPlugin.getDisplay(), pe.width, pe.height);
        } else {
            int width = mBufferImage.getBounds().width;
            int height = mBufferImage.getBounds().height;
            if (width != pe.width || height != pe.height) {
                mBufferImage = new Image(AdtPlugin.getDisplay(), pe.width, pe.height);
            }
        }

        // Draw previous image once for prevent flicking
        pe.gc.drawImage(mBufferImage, 0, 0);

        bufferGc = new GC(mBufferImage);
        bufferGc.setAdvanced(true);

        // Make interpolation disable
        bufferGc.setInterpolation(SWT.NONE);

        // clear buffer
        bufferGc.fillRectangle(0, 0, pe.width, pe.height);

        calcScrollBarSettings();

        // padding from current zoom
        int width = mNinePatchedImage.getWidth();
        int height = mNinePatchedImage.getHeight();
        calcPaddings(width, height);

        int baseX = mPadding.x - mHorizontalScroll;
        int baseY = mPadding.y - mVerticalScroll;

        // draw checker image
        bufferGc.drawImage(mBackgroundLayer,
                0, 0, mBackgroundLayer.getImageData().width,
                mBackgroundLayer.getImageData().height,
                baseX, baseY, mPadding.width, mPadding.height);

        if (DEBUG) {
            System.out.println(String.format("%d,%d %d,%d %d,%d",
                    width, height, baseX, baseY, mPadding.width, mPadding.height));
        }

        // draw image
        /* TODO: Do not draw invisible area, for better performance. */
        bufferGc.drawImage(mNinePatchedImage.getImage(), 0, 0, width, height, baseX, baseY,
                mPadding.width, mPadding.height);

        bufferGc.setBackground(BLACK_COLOR);

        // draw patch ticks
        drawHorizontalPatches(bufferGc, baseX, baseY);
        drawVerticalPatches(bufferGc, baseX, baseY);

        // draw content ticks
        drawHorizontalContentArea(bufferGc, baseX, baseY);
        drawVerticalContentArea(bufferGc, baseX, baseY);

        if (mNinePatchedImage.isValid(mCursorPoint.x, mCursorPoint.y)) {
            bufferGc.setForeground(BLACK_COLOR);
        } else if (mIsLockShown) {
            drawLockArea(bufferGc, baseX, baseY);
        }

        // Patches
        if (mIsPatchesShown) {
            drawPatchAreas(bufferGc, baseX, baseY);
        }

        // Bad patches
        if (mIsBadPatchesShown) {
            drawBadPatchAreas(bufferGc, baseX, baseY);
        }

        if (mNinePatchedImage.isValid(mCursorPoint.x, mCursorPoint.y)) {
            bufferGc.setForeground(BLACK_COLOR);
        } else {
            bufferGc.setForeground(RED_COLOR);
        }

        drawGuideLine(bufferGc, baseX, baseY);

        bufferGc.dispose();

        pe.gc.drawImage(mBufferImage, 0, 0);
    }

    private static final Color getColor(int color) {
        switch (color) {
            case NinePatchedImage.RED_TICK:
                return RED_COLOR;
            default:
                return BLACK_COLOR;
        }
    }

    private void drawVerticalPatches(GC gc, int baseX, int baseY) {
        List<Tick> verticalPatches = mNinePatchedImage.getVerticalPatches();
        for (Tick t : verticalPatches) {
            if (t.color != NinePatchedImage.TRANSPARENT_TICK) {
                gc.setBackground(getColor(t.color));
                gc.fillRectangle(
                        baseX,
                        baseY + getZoomedPixelSize(t.start),
                        mZoomedPixelSize,
                        getZoomedPixelSize(t.getLength()));
            }
        }
    }

    private void drawHorizontalPatches(GC gc, int baseX, int baseY) {
        List<Tick> horizontalPatches = mNinePatchedImage.getHorizontalPatches();
        for (Tick t : horizontalPatches) {
            if (t.color != NinePatchedImage.TRANSPARENT_TICK) {
                gc.setBackground(getColor(t.color));
                gc.fillRectangle(
                        baseX + getZoomedPixelSize(t.start),
                        baseY,
                        getZoomedPixelSize(t.getLength()),
                        mZoomedPixelSize);
            }
        }
    }

    private void drawHorizontalContentArea(GC gc, int baseX, int baseY) {
        List<Tick> horizontalContentArea = mNinePatchedImage.getHorizontalContents();
        for (Tick t : horizontalContentArea) {
            if (t.color != NinePatchedImage.TRANSPARENT_TICK) {
                gc.setBackground(getColor(t.color));
                gc.fillRectangle(
                        baseX + getZoomedPixelSize(t.start),
                        baseY + getZoomedPixelSize(mNinePatchedImage.getHeight() - 1),
                        getZoomedPixelSize(t.getLength()),
                        mZoomedPixelSize);
            }
        }

    }

    private void drawVerticalContentArea(GC gc, int baseX, int baseY) {
        List<Tick> verticalContentArea = mNinePatchedImage.getVerticalContents();
        for (Tick t : verticalContentArea) {
            if (t.color != NinePatchedImage.TRANSPARENT_TICK) {
                gc.setBackground(getColor(t.color));
                gc.fillRectangle(
                        baseX + getZoomedPixelSize(mNinePatchedImage.getWidth() - 1),
                        baseY + getZoomedPixelSize(t.start),
                        mZoomedPixelSize,
                        getZoomedPixelSize(t.getLength()));
            }
        }
    }

    private void drawLockArea(GC gc, int baseX, int baseY) {
        gc.setAlpha(LOCK_ALPHA);
        gc.setForeground(LOCK_COLOR);
        gc.setBackground(LOCK_COLOR);

        gc.fillRectangle(
                baseX + mZoomedPixelSize,
                baseY + mZoomedPixelSize,
                getZoomedPixelSize(mNinePatchedImage.getWidth() - 2),
                getZoomedPixelSize(mNinePatchedImage.getHeight() - 2));
        gc.setAlpha(NONE_ALPHA);

    }

    private void drawPatchAreas(GC gc, int baseX, int baseY) {
        if (mChunks != null) {
            int yLen = mChunks.length;
            int xLen = mChunks[0].length;

            gc.setAlpha(PATCH_ALPHA);

            for (int yPos = 0; yPos < yLen; yPos++) {
                for (int xPos = 0; xPos < xLen; xPos++) {
                    Chunk c = mChunks[yPos][xPos];

                    if (c.type == Chunk.TYPE_FIXED) {
                        gc.setBackground(BACK_COLOR);
                    } else if (c.type == Chunk.TYPE_HORIZONTAL) {
                        gc.setBackground(PATCH_ONEWAY_COLOR);
                    } else if (c.type == Chunk.TYPE_VERTICAL) {
                        gc.setBackground(PATCH_ONEWAY_COLOR);
                    } else if (c.type == Chunk.TYPE_HORIZONTAL + Chunk.TYPE_VERTICAL) {
                        gc.setBackground(PATCH_COLOR);
                    }
                    Rectangle r = c.rect;
                    gc.fillRectangle(
                            baseX + getZoomedPixelSize(r.x),
                            baseY + getZoomedPixelSize(r.y),
                            getZoomedPixelSize(r.width),
                            getZoomedPixelSize(r.height));
                }
            }
        }
        gc.setAlpha(NONE_ALPHA);
    }

    private void drawBadPatchAreas(GC gc, int baseX, int baseY) {
        if (mBadChunks != null) {
            int yLen = mBadChunks.length;
            int xLen = mBadChunks[0].length;

            gc.setAlpha(NONE_ALPHA);
            gc.setForeground(CORRUPTED_COLOR);
            gc.setBackground(CORRUPTED_COLOR);

            for (int yPos = 0; yPos < yLen; yPos++) {
                for (int xPos = 0; xPos < xLen; xPos++) {
                    Chunk c = mBadChunks[yPos][xPos];
                    if ((c.type & Chunk.TYPE_CORRUPT) != 0) {
                        Rectangle r = c.rect;
                        gc.drawRectangle(
                                baseX + getZoomedPixelSize(r.x),
                                baseY + getZoomedPixelSize(r.y),
                                getZoomedPixelSize(r.width),
                                getZoomedPixelSize(r.height));
                    }
                }
            }
        }
    }

    private void drawGuideLine(GC gc, int baseX, int baseY) {
        gc.setAntialias(SWT.ON);
        gc.setInterpolation(SWT.HIGH);

        int x = Math.round((mCursorPoint.x * ((float) mZoom / 100) + baseX)
                + ((float) mZoom / 100 / 2));
        int y = Math.round((mCursorPoint.y * ((float) mZoom / 100) + baseY)
                + ((float) mZoom / 100 / 2));
        gc.setAlpha(GUIDE_ALPHA);

        Point size = getSize();
        gc.drawLine(x, 0, x, size.y);
        gc.drawLine(0, y, size.x, y);

        gc.setAlpha(NONE_ALPHA);
    }

    @Override
    public void keyPressed(KeyEvent event) {
        int keycode = event.keyCode;
        if (keycode == SWT.CTRL) {
            isCtrlPressed = true;
        }
        if (keycode == SWT.SHIFT) {
            isShiftPressed = true;
            if (mStatusChangedListener != null) {
                mStatusChangedListener.helpTextChanged(HELP_MESSAGE_KEY_TIPS2);
            }
        }
    }

    @Override
    public void keyReleased(KeyEvent event) {
        int keycode = event.keyCode;
        if (keycode == SWT.CTRL) {
            isCtrlPressed = false;
        }
        if (keycode == SWT.SHIFT) {
            isShiftPressed = false;
            if (mStatusChangedListener != null) {
                mStatusChangedListener.helpTextChanged(HELP_MESSAGE_KEY_TIPS);
            }
        }
    }

    @Override
    public void dispose() {
        mBackgroundLayer.dispose();
        super.dispose();
    }

    /**
     * Listen image updated event.
     */
    public interface UpdateListener {
        /**
         * 9-patched image has been updated.
         */
        public void update(NinePatchedImage image);
    }

    /**
     * Listen status changed event.
     */
    public interface StatusChangedListener {
        /**
         * Mouse cursor position has been changed.
         */
        public void cursorPositionChanged(int x, int y);

        /**
         * Help text has been changed.
         */
        public void helpTextChanged(String text);
    }
}