/*******************************************************************************

 * Copyright (c) 2000, 2007 IBM Corporation and others.

 * Portion Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     IBM Corporation - initial API and implementation

 *     Nokia Corporation - Qt implementation

 *******************************************************************************/

package org.eclipse.swt.widgets;

import java.util.Vector;

import org.eclipse.ercp.swt.mobile.Command;

import org.eclipse.swt.SWT;

import org.eclipse.swt.SWTException;

import org.eclipse.swt.events.ControlListener;

import org.eclipse.swt.events.FocusListener;

import org.eclipse.swt.events.KeyListener;

import org.eclipse.swt.events.MouseListener;

import org.eclipse.swt.events.MouseMoveListener;

import org.eclipse.swt.events.PaintListener;

import org.eclipse.swt.events.TraverseListener;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.graphics.Drawable;

import org.eclipse.swt.graphics.Font;

import org.eclipse.swt.graphics.GC;

import org.eclipse.swt.graphics.Image;

import org.eclipse.swt.graphics.Internal_GfxPackageSupport;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.swt.internal.qt.CommandUtils;

import org.eclipse.swt.internal.qt.GCData;

import org.eclipse.swt.internal.qt.OS;

import org.eclipse.swt.internal.qt.QObjectDeleteWrapper;

import org.eclipse.swt.internal.qt.SharedGCWrapper;

import org.eclipse.swt.internal.qt.WidgetConstant;

import org.eclipse.swt.internal.qt.WidgetState;

import org.eclipse.swt.internal.qt.graphics.NativeCommandBuffer;

import org.eclipse.swt.internal.qt.graphics.GraphicsContext;

import org.eclipse.swt.internal.qt.graphics.WindowSurface;

/**

 * Control is the abstract superclass of all windowed user interface classes.

 * <p>

 * <dl>

 * <dt><b>Styles:</b>

 * <dd>BORDER</dd>

 * <dd>LEFT_TO_RIGHT, RIGHT_TO_LEFT</dd>

 * <dt><b>Events:</b>

 * <dd>FocusIn, FocusOut, KeyDown, KeyUp, MouseDoubleClick, MouseDown,

 *     MouseUp, MouseMove, Move, Paint, Resize, Traverse</dd>

 * </dl>

 * <p>

 * Only one of LEFT_TO_RIGHT or RIGHT_TO_LEFT may be specified.

 * </p><p>

 * IMPORTANT: This class is intended to be subclassed <em>only</em>

 * within the SWT implementation.

 * </p>

 */

public abstract class Control extends Widget implements Drawable {

    Composite parent;

    int frameHandle, extraStyle;

    Menu menu;

    Font font;

    boolean toolTipTextExists;

    Object layoutData;

    Color foreground, background;

    Image backgroundImage;

    private Command[] commandList;

    // Flags controlling traverse key event handling

    boolean traverseDoit, traverseCancel;

    // Each external GC has its own buffer for now.

    // Not possible to bind several GCs to one buffer.

    Vector/*<GraphicsContext>*/ bufferedGcs;

    Vector/*<Buffer>*/ gcBuffers;

    private byte isPainting;

    boolean bufferFlush;

    WindowSurface windowSurface;

Control() {

}

/**

 * Constructs a new instance of this class given its parent

 * and a style value describing its behavior and appearance.

 * <p>

 * The style value is either one of the style constants defined in

 * class <code>SWT</code> which is applicable to instances of this

 * class, or must be built by <em>bitwise OR</em>'ing together

 * (that is, using the <code>int</code> "|" operator) two or more

 * of those <code>SWT</code> style constants. The class description

 * lists the style constants that are applicable to the class.

 * Style bits are also inherited from superclasses.

 * </p>

 *

 * @param parent a composite control which will be the parent of the new instance (cannot be null)

 * @param style the style of control to construct

 *

 * @exception IllegalArgumentException <ul>

 *    <li>ERROR_NULL_ARGUMENT - if the parent is null</li>

 * </ul>

 * @exception SWTException <ul>

 *    <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent</li>

 *    <li>ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass</li>

 * </ul>

 *

 * @see SWT#BORDER

 * @see Widget#checkSubclass

 * @see Widget#getStyle

 */

public Control(Composite parent, int style) {

    this(parent, style, 0, null, false);

}

/**

 * <p>

 * <b>IMPORTANT:</b> This constructor is <em>not</em> part of the SWT

 * public API. It should never be referenced from application code.

 * </p>

 */

protected Control(Composite parent, int style, int extraStyle, Object packageProxy,

        boolean isExtended) {

    super(parent, style, extraStyle, packageProxy, isExtended);

    this.parent = parent;

    this.extraStyle = extraStyle;

    createWidget(0);

    OS.QWidget_setParent(topHandle, parent.handle);

    OS.QWidget_resize(topHandle, 0, 0);

    if(isParentMirrored()) {

        Point size = OS.QWidget_size(topHandle);

        OS.QWidget_move(topHandle, parent.getClientWidth() - size.x, 0);

    }

    OS.QWidget_setVisible(topHandle, true);

    if(this.parent.packageProxy != null) {

        this.parent.packageProxy.addControl(this);

    } else {

        this.parent.addControl_pp(this);

    }

}

void addCommand(final Command command) {

    if (command.control != this)

        return;

    if (commandList == null) {

        commandList = new Command[1];

        commandList[0] = command;

        return;

    }

    int size = commandList.length;

    for (int i = 0; i < size; i++) {

        if (commandList[i] == command)

            return;

    }

    Command[] newList = new Command[size + 1];

    System.arraycopy(commandList, 0, newList, 0, size);

    newList[size] = command;

    commandList = newList;

}

/**

 * Adds the listener to the collection of listeners who will be notified when

 * the control is moved or resized, by sending it one of the messages defined in

 * the <code>ControlListener</code> interface.

 *

 * @param listener

 *            the listener which should be notified

 *

 * @exception IllegalArgumentException

 *                <ul>

 *                <li>ERROR_NULL_ARGUMENT - if the listener is null</li>

 *                </ul>

 * @exception SWTException

 *                <ul>

 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed

 *                </li> <li>ERROR_THREAD_INVALID_ACCESS - if not called from the

 *                thread that created the receiver</li>

 *                </ul>

 *

 * @see ControlListener

 * @see #removeControlListener

 */

public void addControlListener(ControlListener listener) {

    checkWidget();

    if (listener == null)

        error(SWT.ERROR_NULL_ARGUMENT);

    TypedListener typedListener = new TypedListener(listener);

    addListener(SWT.Resize, typedListener);

    addListener(SWT.Move, typedListener);

}

/**

 * Adds the listener to the collection of listeners who will be notified when

 * the control gains or loses focus, by sending it one of the messages defined

 * in the <code>FocusListener</code> interface.

 *

 * @param listener

 *            the listener which should be notified

 *

 * @exception IllegalArgumentException

 *                <ul>

 *                <li>ERROR_NULL_ARGUMENT - if the listener is null</li>

 *                </ul>

 * @exception SWTException

 *                <ul>

 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed

 *                </li> <li>ERROR_THREAD_INVALID_ACCESS - if not called from the

 *                thread that created the receiver</li>

 *                </ul>

 *

 * @see FocusListener

 * @see #removeFocusListener

 */

public void addFocusListener(FocusListener listener) {

    checkWidget();

    if (listener == null)

        error(SWT.ERROR_NULL_ARGUMENT);

    TypedListener typedListener = new TypedListener(listener);

    addListener(SWT.FocusIn, typedListener);

    addListener(SWT.FocusOut, typedListener);

}

/**

 * Adds the listener to the collection of listeners who will be notified when

 * keys are pressed and released on the system keyboard, by sending it one of

 * the messages defined in the <code>KeyListener</code> interface.

 * <p>

 * When a key listener is added to a control, the control will take part in

 * widget traversal. By default, all traversal keys (such as the tab key and so

 * on) are delivered to the control. In order for a control to take part in

 * traversal, it should listen for traversal events. Otherwise, the user can

 * traverse into a control but not out. Note that native controls such as table

 * and tree implement key traversal in the operating system. It is not necessary

 * to add traversal listeners for these controls, unless you want to override

 * the default traversal.

 * </p>

 *

 * @param listener

 *            the listener which should be notified

 *

 * @exception IllegalArgumentException

 *                <ul>

 *                <li>ERROR_NULL_ARGUMENT - if the listener is null</li>

 *                </ul>

 * @exception SWTException

 *                <ul>

 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>

 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the

 *                thread that created the receiver</li>

 *                </ul>

 *

 * @see KeyListener

 * @see #removeKeyListener

 */

public void addKeyListener(KeyListener listener) {

    checkWidget();

    if (listener == null)

        error(SWT.ERROR_NULL_ARGUMENT);

    TypedListener typedListener = new TypedListener(listener);

    addListener(SWT.KeyUp, typedListener);

    addListener(SWT.KeyDown, typedListener);

}

/**

 * Adds the listener to the collection of listeners who will be notified when

 * mouse buttons are pressed and released, by sending it one of the messages

 * defined in the <code>MouseListener</code> interface.

 *

 * @param listener

 *            the listener which should be notified

 *

 * @exception IllegalArgumentException

 *                <ul>

 *                <li>ERROR_NULL_ARGUMENT - if the listener is null</li>

 *                </ul>

 * @exception SWTException

 *                <ul>

 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>

 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the

 *                thread that created the receiver</li>

 *                </ul>

 *

 * @see MouseListener

 * @see #removeMouseListener

 */

public void addMouseListener(MouseListener listener) {

    checkWidget();

    if (listener == null)

        error(SWT.ERROR_NULL_ARGUMENT);

    TypedListener typedListener = new TypedListener(listener);

    addListener(SWT.MouseDown, typedListener);

    addListener(SWT.MouseUp, typedListener);

    addListener(SWT.MouseDoubleClick, typedListener);

}

/**

 * Adds the listener to the collection of listeners who will be notified when

 * the mouse moves, by sending it one of the messages defined in the

 * <code>MouseMoveListener</code> interface.

 *

 * @param listener

 *            the listener which should be notified

 *

 * @exception IllegalArgumentException

 *                <ul>

 *                <li>ERROR_NULL_ARGUMENT - if the listener is null</li>

 *                </ul>

 * @exception SWTException

 *                <ul>

 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>

 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the

 *                thread that created the receiver</li>

 *                </ul>

 *

 * @see MouseMoveListener

 * @see #removeMouseMoveListener

 */

public void addMouseMoveListener(MouseMoveListener listener) {

    checkWidget();

    if (listener == null)

        error(SWT.ERROR_NULL_ARGUMENT);

    TypedListener typedListener = new TypedListener(listener);

    addListener(SWT.MouseMove, typedListener);

}

/**

 * Adds the listener to the collection of listeners who will be notified when

 * the receiver needs to be painted, by sending it one of the messages defined

 * in the <code>PaintListener</code> interface.

 *

 * @param listener

 *            the listener which should be notified

 *

 * @exception IllegalArgumentException

 *                <ul>

 *                <li>ERROR_NULL_ARGUMENT - if the listener is null</li>

 *                </ul>

 * @exception SWTException

 *                <ul>

 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>

 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the

 *                thread that created the receiver</li>

 *                </ul>

 *

 * @see PaintListener

 * @see #removePaintListener

 */

public void addPaintListener(PaintListener listener) {

    checkWidget();

    if (listener == null)

        error(SWT.ERROR_NULL_ARGUMENT);

    TypedListener typedListener = new TypedListener(listener);

    addListener(SWT.Paint, typedListener);

}

/**

 * Adds the listener to the collection of listeners who will be notified when

 * traversal events occur, by sending it one of the messages defined in the

 * <code>TraverseListener</code> interface.

 *

 * @param listener

 *            the listener which should be notified

 *

 * @exception IllegalArgumentException

 *                <ul>

 *                <li>ERROR_NULL_ARGUMENT - if the listener is null</li>

 *                </ul>

 * @exception SWTException

 *                <ul>

 *                <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li>

 *                <li>ERROR_THREAD_INVALID_ACCESS - if not called from the

 *                thread that created the receiver</li>

 *                </ul>

 *

 * @see TraverseListener

 * @see #removeTraverseListener

 */

public void addTraverseListener(TraverseListener listener) {

    checkWidget();

    if (listener == null)

        error(SWT.ERROR_NULL_ARGUMENT);

    TypedListener typedListener = new TypedListener(listener);

    addListener(SWT.Traverse, typedListener);

}

//This is called with the background control's background color

void applyBackgroundColor(Color color) {

    // Get a temporary copy of the widget's palette, modify the background

    // color, and set the palette back to the widget.

    int palette = OS.QWidget_swt_palette_new(topHandle);

    try {

        setPaletteBgColor(palette, color);

        OS.QWidget_setPalette(topHandle, palette);

    } finally {

        OS.QPalette_delete(palette);

    }

    updateAutoFillBackground();

}

//This is called with the background control's background image

void applyBackgroundImage(Image image) {

    // Get a temporary copy of the widget's palette, modify the background

    // texture, and set the palette back to the widget.

    int palette = OS.QWidget_swt_palette_new(topHandle);

    try {

        setPaletteBgImage(palette, image);

        OS.QWidget_setPalette(topHandle, palette);

    } finally {

        OS.QPalette_delete(palette);

    }

    updateAutoFillBackground();

}

/*

 * Some widgets need to know when background texture is taken into use. They can

 * override this to hook in. E.g. scrolling can't be done but whole area needs

 * repainting if there's a non-single color background in use.

 */

void backgroundImageApplied_pp(Image image) {

}

/*

 * Some widgets need to know when background texture of parent taken into use.

 * They can override this to hook in. E.g. Combo can inherit texture only for

 * some sub-widgets and for some it needs to draw the background image by

 * itself.

 */

void backgroundImageInherited(Image image) {

}

/*

 * Controls that return true here will use null brush for their background

 * role(s) when inheriting a background image. This means they don't draw the

 * background but depend on the parent to draw it. This doesn't work well with

 * some built-in widgets and they will return false here. When this returns

 * false then the background image drawing will be handled by the control itself

 * and the image will appear starting from the control's own origin instead of

 * the parent's.

 */

boolean canInheritBackgroundImage() {

    return true;

}

void checkBackground () {

    Shell shell = getShell ();

    if (this == shell) return;

    state &= ~WidgetState.PARENT_BACKGROUND;

    Composite composite = parent;

    do {

        int mode = composite.backgroundMode;

        if (mode != SWT.INHERIT_NONE) {

            // On some platforms INHERIT_DEFAULT depends on the

            // THEME_BACKGROUND. With Qt we don't have any such criteria

            // but INHERIT_DEFAULT and INHERIT_FORCE have the same effect.

            state |= WidgetState.PARENT_BACKGROUND;

            return;

        }

        if (composite == shell) break;

        composite = composite.parent;

    } while (true);

}

void checkBorder_pp() {

    if (frameHandle != 0) {

        if ((style & SWT.BORDER) == 0) {

            OS.QFrame_setFrameStyle(frameHandle, OS.QT_NOFRAME);

        } else {

            int qStyle = OS.QFrame_frameShape(frameHandle);

            if ((qStyle & (OS.QT_FRAMEPANEL | OS.QT_FRAMEWINPANEL

                    | OS.QT_FRAMESTYLEDPANEL | OS.QT_FRAMEBOX)) == 0) {

                OS.QFrame_setFrameStyle(frameHandle, qStyle

                        | OS.QT_FRAMESTYLEDPANEL);

            }

        }

    }

    // a control has to manage the border by itself if it can't provide a frame

    // handle .

    if (getBorderWidth() == 0)

        // remove border flag if there is no border

        style &= ~SWT.BORDER;

}

void checkBuffered() {

    style &= ~SWT.DOUBLE_BUFFERED;

}

void checkMirrored() {

    if ((style & SWT.RIGHT_TO_LEFT) != 0) {

        style |= SWT.MIRRORED;

    } else {

        style &= ~SWT.MIRRORED;

    }

}

void checkNoBackground() {

    style &= ~SWT.NO_BACKGROUND;

}

void checkNoFocus() {

// Nothing to be done for Control by default. Override case by case.

}

void checkNoRedrawResize() {

    style &= ~SWT.NO_REDRAW_RESIZE;

}

/**

 * Returns the preferred size of the receiver.

 * <p>

 * The <em>preferred size</em> of a control is the size that it would best be

 * displayed at. The width hint and height hint arguments allow the caller to

 * ask a control questions such as "Given a particular width, how high does the

 * control need to be to show all of the contents?" To indicate that the caller

 * does not wish to constrain a particular dimension, the constant

 * <code>SWT.DEFAULT</code> is passed for the hint.

 * </p>

 *

 * @param wHint

 *            the width hint (can be <code>SWT.DEFAULT</code>)