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

 * 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 org.eclipse.ercp.swt.mobile.Command;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.DisposeListener;

import org.eclipse.swt.internal.SWTEventListener;

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

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

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

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

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

/**

 * This class is the abstract superclass of all user interface objects.

 * Widgets are created, disposed and issue notification to listeners

 * when events occur which affect them.

 * <dl>

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

 * <dd>(none)</dd>

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

 * <dd>Dispose</dd>

 * </dl>

 * <p>

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

 * within the SWT implementation. However, it has not been marked

 * final to allow those outside of the SWT development team to implement

 * patched versions of the class in order to get around specific

 * limitations in advance of when those limitations can be addressed

 * by the team.  Any class built using subclassing to access the internals

 * of this class will likely fail to compile or run between releases and

 * may be strongly platform specific. Subclassing should not be attempted

 * without an intimate and detailed understanding of the workings of the

 * hierarchy. No support is provided for user-written classes which are

 * implemented as subclasses of this class.

 * </p>

 *

 * @see #checkSubclass

 */

public abstract class Widget {

    int handle, topHandle;

    int style, state;

    Display display;

    EventTable eventTable;

    Object data;

    PackageProxy packageProxy;

static final int checkBits (int style, int int0, int int1, int int2, int int3, int int4, int int5) {

    int mask = int0 | int1 | int2 | int3 | int4 | int5;

    if ((style & mask) == 0) style |= int0;

    if ((style & int0) != 0) style = (style & ~mask) | int0;

    if ((style & int1) != 0) style = (style & ~mask) | int1;

    if ((style & int2) != 0) style = (style & ~mask) | int2;

    if ((style & int3) != 0) style = (style & ~mask) | int3;

    if ((style & int4) != 0) style = (style & ~mask) | int4;

    if ((style & int5) != 0) style = (style & ~mask) | int5;

    return style;

}

/**

 * Prevents uninitialized instances from being created outside the package.

 */

Widget () {}

/**

 * 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 widget which will be the parent of the new instance (cannot be null)

 * @param style the style of widget to construct

 *

 * @exception IllegalArgumentException <ul>

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

 *    <li>ERROR_INVALID_ARGUMENT - if the parent is disposed</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

 * @see #checkSubclass

 * @see #getStyle

 */

public Widget (Widget 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 Widget (Widget parent, int style, int extraStyle, Object packageProxy, 

        boolean isExtended) {

    checkSubclass ();

    checkParent (parent);

    this.style = style;

    if(isExtended) state |= WidgetState.IS_EXTENDED;

    display = parent.display;

    setPackageProxy(packageProxy);

}

/**

 * Adds the listener to the collection of listeners who will

 * be notified when the widget is disposed. When the widget is

 * disposed, the listener is notified by sending it the

 * <code>widgetDisposed()</code> message.

 *

 * @param listener the listener which should be notified when the receiver is disposed

 *

 * @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 DisposeListener

 * @see #removeDisposeListener

 */

public void addDisposeListener (DisposeListener listener) {

    checkWidget ();

    if (listener == null) error (SWT.ERROR_NULL_ARGUMENT);

    TypedListener typedListener = new TypedListener (listener);

    addListener (SWT.Dispose, typedListener);

}

/**

 * Adds the listener to the collection of listeners who will

 * be notified when an event of the given type occurs. When the

 * event does occur in the widget, the listener is notified by

 * sending it the <code>handleEvent()</code> message. The event

 * type is one of the event constants defined in class <code>SWT</code>.

 *

 * @param eventType the type of event to listen for

 * @param listener the listener which should be notified when the event occurs

 *

 * @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 Listener

 * @see SWT

 * @see #removeListener(int, Listener)

 * @see #notifyListeners

 */

public void addListener (int eventType, Listener listener) {

    checkWidget ();

    if (listener == null) error (SWT.ERROR_NULL_ARGUMENT);

    _addListener (eventType, listener);

}

void _addListener (int eventType, Listener listener) {

    if (eventTable == null) eventTable = new EventTable ();

    eventTable.hook (eventType, listener);

}

final void addWidget (int handle) {

}

final void checkOrientation (Widget parent) {

    style &= ~SWT.MIRRORED;

    // If orientation explicitly specified then always use that

    if ((style & (SWT.LEFT_TO_RIGHT | SWT.RIGHT_TO_LEFT)) == 0) {

        if (parent != null) {

            // Inherit the flag from parent

            if ((parent.style & SWT.LEFT_TO_RIGHT) != 0) style |= SWT.LEFT_TO_RIGHT;

            if ((parent.style & SWT.RIGHT_TO_LEFT) != 0) style |= SWT.RIGHT_TO_LEFT;

            // If the parent follows the system language direction this widget

            // does too (unless the user explicitly specified the direction). 

            state |= (parent.state & WidgetState.FOLLOWS_SYSLANG_DIRECTION);

        } else {

            // Use the default determined by a system property. 

            // Setting RIGHT_TO_LEFT flag triggers the coordinate mirroring. 

            }

            // If there's no parent this widget follows the system language 

            // direction if that's the default behavior configured by a system 

            // property. 

                state |= WidgetState.FOLLOWS_SYSLANG_DIRECTION;

        }

    }

    style = checkBits (style, SWT.LEFT_TO_RIGHT, SWT.RIGHT_TO_LEFT, 0, 0, 0, 0);

}

/*

 * Throws an exception if the specified widget can not be

 * used as a parent for the receiver.

 *

 * @exception IllegalArgumentException <ul>

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

 *    <li>ERROR_INVALID_ARGUMENT - if the parent is disposed</li>

 * </ul>

 * @exception SWTException <ul>

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

 * </ul>

 */

final void checkParent (Widget parent) {

    if (parent == null) error (SWT.ERROR_NULL_ARGUMENT);

    if (parent.isDisposed ()) error (SWT.ERROR_INVALID_ARGUMENT);

    parent.checkWidget ();

}

/**

 * Checks that this class can be subclassed.

 * <p>

 * The SWT class library is intended to be subclassed

 * only at specific, controlled points (most notably,

 * <code>Composite</code> and <code>Canvas</code> when

 * implementing new widgets). This method enforces this

 * rule unless it is overridden.

 * </p><p>

 * <em>IMPORTANT:</em> By providing an implementation of this

 * method that allows a subclass of a class which does not

 * normally allow subclassing to be created, the implementer

 * agrees to be fully responsible for the fact that any such

 * subclass will likely fail between SWT releases and will be

 * strongly platform specific. No support is provided for

 * user-written classes which are implemented in this fashion.

 * </p><p>

 * The ability to subclass outside of the allowed SWT classes

 * is intended purely to enable those not on the SWT development

 * team to implement patches in order to get around specific

 * limitations in advance of when those limitations can be

 * addressed by the team. Subclassing should not be attempted

 * without an intimate and detailed understanding of the hierarchy.

 * </p>

 *

 * @exception SWTException <ul>

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

 * </ul>

 */

protected void checkSubclass () {

    if (!isValidSubclass ()) error (SWT.ERROR_INVALID_SUBCLASS);

}

/**

 * Throws an <code>SWTException</code> if the receiver can not

 * be accessed by the caller. This may include both checks on

 * the state of the receiver and more generally on the entire

 * execution context. This method <em>should</em> be called by

 * widget implementors to enforce the standard SWT invariants.

 * <p>

 * Currently, it is an error to invoke any method (other than

 * <code>isDisposed()</code>) on a widget that has had its

 * <code>dispose()</code> method called. It is also an error

 * to call widget methods from any thread that is different

 * from the thread that created the widget.

 * </p><p>

 * In future releases of SWT, there may be more or fewer error

 * checks and exceptions may be thrown for different reasons.

 * </p>

 *

 * @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>

 */

protected void checkWidget () {

    Display display = this.display;

    if (display == null) error (SWT.ERROR_WIDGET_DISPOSED);

    if (display.thread != Thread.currentThread ()) error (SWT.ERROR_THREAD_INVALID_ACCESS);

    if ((state & WidgetState.DISPOSED) != 0) error (SWT.ERROR_WIDGET_DISPOSED);

}

/*

 * _pp means that some widgets want to "override" this method in another 

 * package. If this is such a widget then there is a 'package proxy' (pp) that 

 * must be called instead of the implementation in this package. 

 */ 

void createHandle_pp (int index) {

}

void createWidget (int index) {

    if(packageProxy != null) {

        packageProxy.createHandle(index);

    } else {

        createHandle_pp (index);

    }

    // If subclasses didn't specify topHandle then it's assumed that there's

    // only one QWidget. I.e. handle is the root widget. 

    if(topHandle == 0) topHandle = handle;

    if(packageProxy != null) {

        packageProxy.hookEvents();

    } else {

        hookEvents_pp();

    }

    if(packageProxy != null) {

        packageProxy.register();

    } else {

        register_pp();

    }

}

void deregister_pp () {

}

void destroyWidget () {

    int _topHandle = topHandle;

    if(packageProxy != null) {

        packageProxy.releaseHandle();

    } else {

        releaseHandle_pp ();

    }

    if (_topHandle != 0 && (state & WidgetState.HANDLE) != 0) {

        QObjectDeleteWrapper.deleteSafely( _topHandle );

    }

}

/**

 * Disposes of the operating system resources associated with

 * the receiver and all its descendants. After this method has

 * been invoked, the receiver and all descendants will answer

 * <code>true</code> when sent the message <code>isDisposed()</code>.

 * Any internal connections between the widgets in the tree will

 * have been removed to facilitate garbage collection.

 * <p>

 * NOTE: This method is not called recursively on the descendants

 * of the receiver. This means that, widget implementers can not

 * detect when a widget is being disposed of by re-implementing

 * this method, but should instead listen for the <code>Dispose</code>

 * event.

 * </p>

 *

 * @exception SWTException <ul>

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

 * </ul>

 *

 * @see #addDisposeListener

 * @see #removeDisposeListener

 * @see #checkWidget

 */

public void dispose () {

    if (isDisposed ()) return;

    if (!isValidThread ()) error (SWT.ERROR_THREAD_INVALID_ACCESS);

    release (true);

}

final void error (int code) {

    SWT.error (code);

}

final boolean filters (int eventType) {

}

static final Command[] getCommands(Control control) {

    return control.getCommands();

}

/**

 * Returns the application defined widget data associated

 * with the receiver, or null if it has not been set. The

 * <em>widget data</em> is a single, unnamed field that is

 * stored with every widget.

 * <p>

 * Applications may put arbitrary objects in this field. If

 * the object stored in the widget data needs to be notified

 * when the widget is disposed of, it is the application's

 * responsibility to hook the Dispose event on the widget and

 * do so.

 * </p>

 *

 * @return the widget data

 *

 * @exception SWTException <ul>

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

 *    <li>ERROR_THREAD_INVALID_ACCESS - when called from the wrong thread</li>

 * </ul>

 *

 * @see #setData(Object)

 */

public Object getData () {

    checkWidget();

    return (state & WidgetState.KEYED_DATA) != 0 ? ((Object []) data) [0] : data;

}

/**

 * Returns the application defined property of the receiver

 * with the specified name, or null if it has not been set.

 * <p>

 * Applications may have associated arbitrary objects with the

 * receiver in this fashion. If the objects stored in the

 * properties need to be notified when the widget is disposed

 * of, it is the application's responsibility to hook the

 * Dispose event on the widget and do so.

 * </p>

 *

 * @param   key the name of the property

 * @return the value of the property or null if it has not been set

 *

 * @exception IllegalArgumentException <ul>

 *    <li>ERROR_NULL_ARGUMENT - if the key 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 #setData(String, Object)

 */

public Object getData (String key) {

    checkWidget();

    if (key == null) error (SWT.ERROR_NULL_ARGUMENT);

    if ((state & WidgetState.KEYED_DATA) != 0) {

        Object [] table = (Object []) data;

        for (int i=1; i<table.length; i+=2) {

            if (key.equals (table [i])) return table [i+1];

        }

    }

    return null;

}

/**

 * Returns the <code>Display</code> that is associated with

 * the receiver.

 * <p>

 * A widget's display is either provided when it is created

 * (for example, top level <code>Shell</code>s) or is the

 * same as its parent's display.

 * </p>

 *

 * @return the receiver's display

 *

 * @exception SWTException <ul>

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

 * </ul>

 */

public Display getDisplay () {

    Display display = this.display;

    if (display == null) error (SWT.ERROR_WIDGET_DISPOSED);

    return display;

}

String getName () {

    String string = getClass ().getName ();

    int index = string.length ();

    while ((--index > 0) && (string.charAt (index) != '.')) {}

    return string.substring (index + 1, string.length ());

}

String getNameText () {

    return "";

}

String getPhoneNumber_pp() {

    if (packageProxy != null) {

        return packageProxy.getPhoneNumber();

    }

    return null;

}

/**

 * Returns the receiver's style information.

 * <p>

 * Note that the value which is returned by this method <em>may

 * not match</em> the value which was provided to the constructor

 * when the receiver was created. This can occur when the underlying

 * operating system does not support a particular combination of

 * requested styles. For example, if the platform widget used to

 * implement a particular SWT widget always has scroll bars, the

 * result of calling this method would always have the

 * <code>SWT.H_SCROLL</code> and <code>SWT.V_SCROLL</code> bits set.

 * </p>

 *

 * @return the style bits

 *

 * @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>

 */

public int getStyle () {

    checkWidget ();

    return style;

}

// Experimental support for StyleSheets

public String getStyleSheet(){

    checkWidget();

    return OS.QWidget_styleSheet(handle);

}

void hookEvents_pp () {

}

/*

 * Returns <code>true</code> if the specified eventType is

 * hooked, and <code>false</code> otherwise. Implementations

 * of SWT can avoid creating objects and sending events

 * when an event happens in the operating system but