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

 * 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.swt.SWT;

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.OS;

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

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

/**

 * Instances of this class provide the appearance and

 * behavior of <code>Shells</code>, but are not top

 * level shells or dialogs. Class <code>Shell</code>

 * shares a significant amount of code with this class,

 * and is a subclass.

 * <p>

 * IMPORTANT: This class was intended to be abstract and

 * should <em>never</em> be referenced or instantiated.

 * Instead, the class <code>Shell</code> should be used.

 * </p>

 * <p>

 * Instances are always displayed in one of the maximized,

 * minimized or normal states:

 * <ul>

 * <li>

 * When an instance is marked as <em>maximized</em>, the

 * window manager will typically resize it to fill the

 * entire visible area of the display, and the instance

 * is usually put in a state where it can not be resized

 * (even if it has style <code>RESIZE</code>) until it is

 * no longer maximized.

 * </li><li>

 * When an instance is in the <em>normal</em> state (neither

 * maximized or minimized), its appearance is controlled by

 * the style constants which were specified when it was created

 * and the restrictions of the window manager (see below).

 * </li><li>

 * When an instance has been marked as <em>minimized</em>,

 * its contents (client area) will usually not be visible,

 * and depending on the window manager, it may be

 * "iconified" (that is, replaced on the desktop by a small

 * simplified representation of itself), relocated to a

 * distinguished area of the screen, or hidden. Combinations

 * of these changes are also possible.

 * </li>

 * </ul>

 * </p>

 * Note: The styles supported by this class must be treated

 * as <em>HINT</em>s, since the window manager for the

 * desktop on which the instance is visible has ultimate

 * control over the appearance and behavior of decorations.

 * For example, some window managers only support resizable

 * windows and will always assume the RESIZE style, even if

 * it is not set.

 * <dl>

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

 * <dd>BORDER, CLOSE, MIN, MAX, NO_TRIM, RESIZE, TITLE, ON_TOP</dd>

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

 * <dd>(none)</dd>

 * </dl>

 * Class <code>SWT</code> provides two "convenience constants"

 * for the most commonly required style combinations:

 * <dl>

 * <dt><code>SHELL_TRIM</code></dt>

 * <dd>

 * the result of combining the constants which are required

 * to produce a typical application top level shell: (that

 * is, <code>CLOSE | TITLE | MIN | MAX | RESIZE</code>)

 * </dd>

 * <dt><code>DIALOG_TRIM</code></dt>

 * <dd>

 * the result of combining the constants which are required

 * to produce a typical application dialog shell: (that

 * is, <code>TITLE | CLOSE | BORDER</code>)

 * </dd>

 * </dl>

 * <p>

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

 * within the SWT implementation.

 * </p>

 *

 * @see #getMinimized

 * @see #getMaximized

 * @see Shell

 * @see SWT

 */

public class Decorations extends Canvas {

    Image image;

    Menu menuBar;

    Menu [] menus;

    Control savedFocus;

    Button defaultButton, saveDefault;

    // Window state information for restoring the previous state

    int restoreState;

    Point fixedSize;

    // Holds the handle to the internal menu bar

    private int ownMenuBar;

    // Learned dimensions of normal window trim with title bar

    static int topTitleFrame = -1;

    static int leftTitleFrame = -1;

    static int rightTitleFrame = -1;

    static int bottomTitleFrame = -1;

    // Learned dimensions of thin window trim without title bar

    static int topThinFrame = -1;

    static int leftThinFrame = -1;

    static int rightThinFrame = -1;

    static int bottomThinFrame = -1;

Decorations () {

    /* Do nothing */

}

/**

 * 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 SWT#CLOSE

 * @see SWT#MIN

 * @see SWT#MAX

 * @see SWT#RESIZE

 * @see SWT#TITLE

 * @see SWT#NO_TRIM

 * @see SWT#SHELL_TRIM

 * @see SWT#DIALOG_TRIM

 * @see SWT#ON_TOP

 * @see Widget#checkSubclass

 * @see Widget#getStyle

 */

public Decorations (Composite parent, int style) {

    super (parent, checkStyle (style, parent));

}

static int checkStyle (int style, Composite parent) {

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

        style &= ~(SWT.CLOSE | SWT.TITLE | SWT.MIN | SWT.MAX | SWT.RESIZE | SWT.BORDER);

    }

    if ((style & (SWT.MENU | SWT.MIN | SWT.MAX | SWT.CLOSE)) != 0) {

        style |= SWT.TITLE;

    }

    return style;

}

protected void checkSubclass () {

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

}

void checkBorder_pp() {

    // For Shells SWT.BORDER means dialog window border. Not QFrame border.

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

        if(frameHandle != 0) {

            OS.QFrame_setFrameStyle(frameHandle, OS.QT_NOFRAME);

        }

    } else {

        super.checkBorder_pp ();

    }

}

void addMenu (Menu menu) {

    if (menus == null) menus = new Menu [4];

    for (int i=0; i<menus.length; i++) {

        if (menus [i] == null) {

            menus [i] = menu;

            return;

        }

    }

    Menu [] newMenus = new Menu [menus.length + 4];

    newMenus [menus.length] = menu;

    System.arraycopy (menus, 0, newMenus, 0, menus.length);

    menus = newMenus;

}

Control computeTabGroup () {

    return this;

}

Control computeTabRoot () {

    return this;

}

public void dispose () {

    if (isDisposed()) return;

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

    super.dispose ();

}

/**

 * Returns the receiver's default button if one had

 * previously been set, otherwise returns null.

 *

 * @return the default button or null

 *

 * @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 #setDefaultButton(Button)

 */

public Button getDefaultButton () {

    checkWidget();

    return defaultButton;

}

/**

 * Returns the receiver's image if it had previously been

 * set using <code>setImage()</code>. The image is typically

 * displayed by the window manager when the instance is

 * marked as iconified, and may also be displayed somewhere

 * in the trim when the instance is in normal or maximized

 * states.

 * <p>

 * Note: This method will return null if called before

 * <code>setImage()</code> is called. It does not provide

 * access to a window manager provided, "default" image

 * even if one exists.

 * </p>

 *

 * @return the image

 *

 * @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 Image getImage () {

    checkWidget ();

    return image;

}

/**

 * Returns <code>true</code> if the receiver is currently

 * maximized, and false otherwise.

 * <p>

 *

 * @return the maximized state

 *

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

 */

public boolean getMaximized () {

    checkWidget();

    return hasState(OS.QT_WINDOWMAXIMIZED);

}

/**

 * Returns the receiver's menu bar if one had previously

 * been set, otherwise returns null.

 *

 * @return the menu bar or null

 *

 * @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 Menu getMenuBar () {

    checkWidget();

    return menuBar;

}

/*

 *  Returns the handle to the menu bar. Creates an internal

 *  Menu bar if there is no menu bar set. If there is already

 *  a menu bar it returns the handle for that.

 */

public int internal_getOwnMenuBar(){

    if( menuBar != null && !menuBar.isDisposed() ){

        return menuBar.handle;

    }

    if ( ownMenuBar == 0 ){

        ownMenuBar = OS.QMenuBar_new(topHandle);

        if (parent == null ){

            OS.QMainWindow_setMenuBar(topHandle, ownMenuBar);

        }

        else{

            int layout = OS.QWidget_layout(topHandle);

            OS.QLayout_setMenuBar( layout,  ownMenuBar );

        }

    }

    return ownMenuBar;

}

/*

 * Destroys the own menu bar if there is one.

 */

public void internal_destroyOwnMenuBar(){

    if (ownMenuBar != 0 ){

        QObjectDeleteWrapper.deleteSafely( ownMenuBar );

        ownMenuBar = 0;

    }

}

/**

 * Returns <code>true</code> if the receiver is currently

 * minimized, and false otherwise.

 * <p>

 *

 * @return the minimized state

 *

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

 */

public boolean getMinimized () {

    checkWidget();

    return hasState(OS.QT_WINDOWMINIMIZED);

}

String getNameText () {

    return getText ();

}

/**

 * Returns the receiver's text, which is the string that the

 * window manager will typically display as the receiver's

 * <em>title</em>. If the text has not previously been set,

 * returns an empty string.

 *

 * @return the text

 *

 * @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 String getText () {

    checkWidget();

    return OS.QWidget_windowTitle(topHandle);

}

public boolean isReparentable () {

    checkWidget ();

    return false;

}

boolean isTabGroup () {

    return true;

}

boolean isTabItem () {

    return false;

}

Decorations menuShell () {

    return this;

}

void removeMenu (Menu menu) {

    if (menus == null) return;

    for (int i=0; i<menus.length; i++) {

        if (menus [i] == menu) {

            menus [i] = null;

            return;

        }

    }

}

void releaseChildren_pp (boolean destroy) {

    if (menuBar != null) {

        menuBar.release (false);

        menuBar = null;

    }

    internal_destroyOwnMenuBar();

    super.releaseChildren_pp (destroy);

    if (menus != null) {

        for (int i=0; i<menus.length; i++) {

            Menu menu = menus [i];

            if (menu != null && !menu.isDisposed ()) {

                menu.dispose ();

            }

        }

        menus = null;

    }

}

void releaseWidget_pp () {

    super.releaseWidget_pp ();

    image = null;

    savedFocus = null;

    defaultButton = saveDefault = null;

}

boolean restoreFocus () {

    if (savedFocus != null && savedFocus.isDisposed ()) savedFocus = null;

    boolean restored = savedFocus != null && savedFocus.setFocus (OS.QT_OTHERFOCUSREASON);

    /*

    * This code is intentionally commented.  When no widget

    * has been given focus, some platforms give focus to the

    * default button. We don't do this.

    */

//  if (restored) return true;

//  if (defaultButton != null && !defaultButton.isDisposed ()) {

//      if (defaultButton.setFocus ()) return true;

//  }

    return restored;

}

/**

 * If the argument is not null, sets the receiver's default

 * button to the argument, and if the argument is null, sets

 * the receiver's default button to the first button which

 * was set as the receiver's default button (called the

 * <em>saved default button</em>). If no default button had

 * previously been set, or the saved default button was

 * disposed, the receiver's default button will be set to

 * null.

 * <p>

 * The default button is the button that is selected when

 * the receiver is active and the user presses ENTER.

 * </p>

 *

 * @param button the new default button

 *

 * @exception IllegalArgumentException <ul>

 *    <li>ERROR_INVALID_ARGUMENT - if the button has been disposed</li>

 *    <li>ERROR_INVALID_PARENT - if the control is not in the same widget tree</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>

 */

public void setDefaultButton (Button button) {

    checkWidget ();

    if (button != null) {

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

        if (button.menuShell () != this) error(SWT.ERROR_INVALID_PARENT);

    }

    setDefaultButton (button, true);

}

void setDefaultButton (Button button, boolean save) {

    if (button == null) {

        if (defaultButton == saveDefault) {

            if (save) saveDefault = null;

            return;

        }

    } else {

        if ((button.style & SWT.PUSH) == 0) return;

        if (button == defaultButton) return;

    }

    if (defaultButton != null) {

        if (!defaultButton.isDisposed ()) defaultButton.setDefault (false);

    }

    if ((defaultButton = button) == null) defaultButton = saveDefault;

    if (defaultButton != null) {

        if (!defaultButton.isDisposed ()) defaultButton.setDefault (true);

    }

    if (save) saveDefault = defaultButton;

    if (saveDefault != null && saveDefault.isDisposed ()) saveDefault = null;

}

/**

 * Sets the receiver's image to the argument, which may

 * be null. The image is typically displayed by the window

 * manager when the instance is marked as iconified, and

 * may also be displayed somewhere in the trim when the

 * instance is in normal or maximized states.

 *

 * @param image the new image (or null)

 *

 * @exception IllegalArgumentException <ul>

 *    <li>ERROR_INVALID_ARGUMENT - if the image has been disposed</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>

 */

public void setImage (Image image) {

    checkWidget ();

    if (image != null && image.isDisposed()) error(SWT.ERROR_INVALID_ARGUMENT);

    this.image = image;

    int icon = (image != null ? Internal_GfxPackageSupport.getIconHandle(image) :

        Internal_GfxPackageSupport.getNullIconHandle());

    OS.QWidget_setWindowIcon(topHandle, icon);

}

/**

 * Sets the maximized state of the receiver.