| package org.eclipse.swt.widgets;
|
|
|
| /*
|
| * Copyright (c) 2000, 2002 IBM Corp. All rights reserved. |
| * This file is made available under the terms of the Common Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/cpl-v10.html
|
| */
|
|
|
| import org.eclipse.swt.*;
|
| import org.eclipse.swt.internal.*;
|
| import org.eclipse.swt.internal.gtk.*;
|
| import org.eclipse.swt.graphics.*;
|
| import org.eclipse.swt.graphics.*;
|
|
|
| /**
|
| * 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>
|
| * 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, TOOL</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 {
|
| String text;
|
| Image image;
|
| boolean minimized, maximized;
|
| Menu menuBar;
|
| Menu [] menus;
|
| Button defaultButton, currentDefault;
|
| int accelGroup;
|
|
|
| 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 SWT#TOOL
|
| * @see Widget#checkSubclass
|
| * @see Widget#getStyle
|
| */ |
| public Decorations (Composite parent, int style) {
|
| super (parent, checkStyle (style));
|
| }
|
|
|
| static int checkStyle (int style) {
|
| if ((style & (SWT.MENU | SWT.MIN | SWT.MAX | SWT.CLOSE)) != 0) {
|
| style |= SWT.TITLE;
|
| }
|
| return style;
|
| }
|
|
|
| void add (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;
|
| }
|
|
|
| void createAccelGroup () {
|
| if (accelGroup != 0) return;
|
| accelGroup = OS.gtk_accel_group_new ();
|
| if (accelGroup == 0) SWT.error (SWT.ERROR_NO_HANDLES);
|
| //FIXME - what should we do for Decorations
|
| int shellHandle = topHandle ();
|
| OS.gtk_window_add_accel_group (shellHandle, accelGroup);
|
| if (menuBar != null) menuBar.addAccelerators (accelGroup);
|
| }
|
|
|
| void createWidget (int index) {
|
| super.createWidget (index);
|
| text = "";
|
| }
|
|
|
| void destroyAccelGroup () {
|
| if (accelGroup != 0) {
|
| int shellHandle = topHandle ();
|
| OS.gtk_window_remove_accel_group (shellHandle, accelGroup);
|
| //TEMPORARY CODE
|
| // OS.g_object_unref (accelGroup);
|
| }
|
| accelGroup = 0;
|
| }
|
|
|
| /**
|
| * 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
|
| */ |
| public Button getDefaultButton () {
|
| checkWidget();
|
| return currentDefault != null ? currentDefault : 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 maximized;
|
| }
|
|
|
| /**
|
| * 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 <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 minimized;
|
| }
|
|
|
| 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 text;
|
| }
|
|
|
| boolean isTabGroup () {
|
| return true;
|
| }
|
|
|
| boolean isTabItem () {
|
| return false;
|
| }
|
|
|
| Decorations menuShell () {
|
| return this;
|
| }
|
|
|
| void remove (Menu menu) {
|
| if (menus == null) return;
|
| for (int i=0; i<menus.length; i++) {
|
| if (menus [i] == menu) {
|
| menus [i] = null;
|
| return;
|
| }
|
| }
|
| }
|
|
|
| void releaseWidget () {
|
| if (menuBar != null) {
|
| menuBar.releaseWidget ();
|
| menuBar.releaseHandle ();
|
| }
|
| menuBar = null;
|
| if (menus != null) {
|
| for (int i=0; i<menus.length; i++) {
|
| Menu menu = menus [i];
|
| if (menu != null && !menu.isDisposed ()) {
|
| menu.dispose ();
|
| }
|
| }
|
| }
|
| menus = null;
|
| super.releaseWidget ();
|
| image = null;
|
| }
|
|
|
| /**
|
| * 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.
|
| *
|
| * @param the new default button
|
| *
|
| * @exception IllegalArgumentException <ul>
|
| * <li>ERROR_INVALID_ARGUMENT - if the button 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 setDefaultButton (Button button) {
|
| checkWidget();
|
| int buttonHandle = 0;
|
| if (button != null) {
|
| if (button.isDisposed ()) error (SWT.ERROR_INVALID_ARGUMENT);
|
| buttonHandle = button.handle;
|
| }
|
| this.defaultButton = button;
|
| OS.gtk_window_set_default (topHandle (), buttonHandle);
|
| }
|
|
|
| /**
|
| * 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();
|
| this.image = image;
|
| int pixmap = 0, mask = 0;
|
| if (image != null) {
|
| pixmap = image.pixmap;
|
| mask = image.mask;
|
| }
|
| int window = OS.GTK_WIDGET_WINDOW(topHandle());
|
| OS.gdk_window_set_icon (window, 0, pixmap, mask);
|
| }
|
|
|
| /**
|
| * Sets the maximized state of the receiver.
|
| * If the argument is <code>true</code> causes the receiver
|
| * to switch to the maximized state, and if the argument is
|
| * <code>false</code> and the receiver was previously maximized,
|
| * causes the receiver to switch back to either the minimized
|
| * or normal states.
|
| * <p>
|
| * Note: The result of intermixing calls to<code>setMaximized(true)</code>
|
| * and <code>setMinimized(true)</code> will vary by platform. Typically,
|
| * the behavior will match the platform user's expectations, but not
|
| * always. This should be avoided if possible.
|
| * </p>
|
| *
|
| * @param the new 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 #setMinimized
|
| */ |
| public void setMaximized (boolean maximized) {
|
| checkWidget();
|
| this.maximized = maximized;
|
| }
|
|
|
| /**
|
| * Sets the receiver's menu bar to the argument, which
|
| * may be null.
|
| *
|
| * @param menu the new menu bar
|
| *
|
| * @exception IllegalArgumentException <ul>
|
| * <li>ERROR_INVALID_ARGUMENT - if the menu has been disposed</li>
|
| * <li>ERROR_INVALID_PARENT - if the menu 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 setMenuBar (Menu menu) {
|
| checkWidget();
|
| if (menuBar == menu) return;
|
| if (menu != null) {
|
| if ((menu.style & SWT.BAR) == 0) error (SWT.ERROR_MENU_NOT_BAR);
|
| if (menu.parent != this) error (SWT.ERROR_INVALID_PARENT);
|
| }
|
| menuBar = menu;
|
| }
|
|
|
| /**
|
| * Sets the minimized stated of the receiver.
|
| * If the argument is <code>true</code> causes the receiver
|
| * to switch to the minimized state, and if the argument is
|
| * <code>false</code> and the receiver was previously minimized,
|
| * causes the receiver to switch back to either the maximized
|
| * or normal states.
|
| * <p>
|
| * Note: The result of intermixing calls to<code>setMaximized(true)</code>
|
| * and <code>setMinimized(true)</code> will vary by platform. Typically,
|
| * the behavior will match the platform user's expectations, but not
|
| * always. This should be avoided if possible.
|
| * </p>
|
| *
|
| * @param the new 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 void setMinimized (boolean minimized) {
|
| checkWidget();
|
| this.minimized = minimized;
|
| }
|
|
|
| /**
|
| * Sets the receiver's text, which is the string that the
|
| * window manager will typically display as the receiver's
|
| * <em>title</em>, to the argument, which may not be null.
|
| *
|
| * @param text the new text
|
| *
|
| * @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>
|
| */ |
| public void setText (String string) {
|
| checkWidget();
|
| if (string == null) error (SWT.ERROR_NULL_ARGUMENT);
|
| text = string;
|
| }
|
|
|
| boolean traverseItem (boolean next) {
|
| return false;
|
| }
|
|
|
| boolean traverseReturn () {
|
| int shellHandle = _getShell ().topHandle ();
|
| boolean processed = OS.gtk_window_activate_default(shellHandle);
|
| return processed;
|
| }
|
|
|
| }
|