jdk/src/solaris/classes/sun/awt/X11/XDecoratedPeer.java
author yan
Mon, 06 Oct 2008 16:45:00 +0400
changeset 1966 12a51fb0db0d
parent 449 7820f232278d
child 1977 3a9980ccb120
permissions -rw-r--r--
5100701: Toolkit.getLockingKeyState() does not work on XToolkit, but works on Motif Summary: Does not work on Motif but works on XToolkit now; implemented using XQueryPointer. Reviewed-by: anthony
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     1
/*
439
3488710b02f8 6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents: 420
diff changeset
     2
 * Copyright 2002-2008 Sun Microsystems, Inc.  All Rights Reserved.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
90ce3da70b43 Initial load
duke
parents:
diff changeset
     4
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
90ce3da70b43 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
90ce3da70b43 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.  Sun designates this
90ce3da70b43 Initial load
duke
parents:
diff changeset
     8
 * particular file as subject to the "Classpath" exception as provided
90ce3da70b43 Initial load
duke
parents:
diff changeset
     9
 * by Sun in the LICENSE file that accompanied this code.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    10
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    11
 * This code is distributed in the hope that it will be useful, but WITHOUT
90ce3da70b43 Initial load
duke
parents:
diff changeset
    12
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
90ce3da70b43 Initial load
duke
parents:
diff changeset
    13
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
90ce3da70b43 Initial load
duke
parents:
diff changeset
    14
 * version 2 for more details (a copy is included in the LICENSE file that
90ce3da70b43 Initial load
duke
parents:
diff changeset
    15
 * accompanied this code).
90ce3da70b43 Initial load
duke
parents:
diff changeset
    16
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    17
 * You should have received a copy of the GNU General Public License version
90ce3da70b43 Initial load
duke
parents:
diff changeset
    18
 * 2 along with this work; if not, write to the Free Software Foundation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    19
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    20
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    21
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    22
 * CA 95054 USA or visit www.sun.com if you need additional information or
90ce3da70b43 Initial load
duke
parents:
diff changeset
    23
 * have any questions.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    24
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    25
package sun.awt.X11;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    26
90ce3da70b43 Initial load
duke
parents:
diff changeset
    27
import java.awt.*;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    28
90ce3da70b43 Initial load
duke
parents:
diff changeset
    29
import java.awt.event.ComponentEvent;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    30
import java.awt.event.InvocationEvent;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    31
import java.awt.event.WindowEvent;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    32
90ce3da70b43 Initial load
duke
parents:
diff changeset
    33
import java.util.logging.Level;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    34
import java.util.logging.Logger;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    35
90ce3da70b43 Initial load
duke
parents:
diff changeset
    36
import sun.awt.ComponentAccessor;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    37
import sun.awt.SunToolkit;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    38
129
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
    39
abstract class XDecoratedPeer extends XWindowPeer {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    40
    private static final Logger log = Logger.getLogger("sun.awt.X11.XDecoratedPeer");
90ce3da70b43 Initial load
duke
parents:
diff changeset
    41
    private static final Logger insLog = Logger.getLogger("sun.awt.X11.insets.XDecoratedPeer");
90ce3da70b43 Initial load
duke
parents:
diff changeset
    42
    private static final Logger focusLog = Logger.getLogger("sun.awt.X11.focus.XDecoratedPeer");
449
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
    43
    private static final Logger iconLog = Logger.getLogger("sun.awt.X11.icon.XDecoratedPeer");
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    44
90ce3da70b43 Initial load
duke
parents:
diff changeset
    45
    // Set to true when we get the first ConfigureNotify after being
90ce3da70b43 Initial load
duke
parents:
diff changeset
    46
    // reparented - indicates that WM has adopted the top-level.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    47
    boolean configure_seen;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    48
    boolean insets_corrected;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    49
90ce3da70b43 Initial load
duke
parents:
diff changeset
    50
    XIconWindow iconWindow;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    51
    WindowDimensions dimensions;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    52
    XContentWindow content;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    53
    Insets currentInsets;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    54
    XFocusProxyWindow focusProxy;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    55
90ce3da70b43 Initial load
duke
parents:
diff changeset
    56
    XDecoratedPeer(Window target) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    57
        super(target);
90ce3da70b43 Initial load
duke
parents:
diff changeset
    58
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    59
90ce3da70b43 Initial load
duke
parents:
diff changeset
    60
    XDecoratedPeer(XCreateWindowParams params) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    61
        super(params);
90ce3da70b43 Initial load
duke
parents:
diff changeset
    62
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    63
90ce3da70b43 Initial load
duke
parents:
diff changeset
    64
    public long getShell() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    65
        return window;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    66
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    67
90ce3da70b43 Initial load
duke
parents:
diff changeset
    68
    public long getContentWindow() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    69
        return (content == null) ? window : content.getWindow();
90ce3da70b43 Initial load
duke
parents:
diff changeset
    70
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    71
90ce3da70b43 Initial load
duke
parents:
diff changeset
    72
    void preInit(XCreateWindowParams params) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    73
        super.preInit(params);
90ce3da70b43 Initial load
duke
parents:
diff changeset
    74
        winAttr.initialFocus = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    75
449
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
    76
        currentInsets = new Insets(0,0,0,0);
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
    77
        applyGuessedInsets();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    78
90ce3da70b43 Initial load
duke
parents:
diff changeset
    79
        Rectangle bounds = (Rectangle)params.get(BOUNDS);
90ce3da70b43 Initial load
duke
parents:
diff changeset
    80
        dimensions = new WindowDimensions(bounds, getRealInsets(), false);
90ce3da70b43 Initial load
duke
parents:
diff changeset
    81
        params.put(BOUNDS, dimensions.getClientRect());
90ce3da70b43 Initial load
duke
parents:
diff changeset
    82
        insLog.log(Level.FINE, "Initial dimensions {0}", new Object[] { dimensions });
90ce3da70b43 Initial load
duke
parents:
diff changeset
    83
90ce3da70b43 Initial load
duke
parents:
diff changeset
    84
        // Deny default processing of these events on the shell - proxy will take care of
90ce3da70b43 Initial load
duke
parents:
diff changeset
    85
        // them instead
90ce3da70b43 Initial load
duke
parents:
diff changeset
    86
        Long eventMask = (Long)params.get(EVENT_MASK);
439
3488710b02f8 6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents: 420
diff changeset
    87
        params.add(EVENT_MASK, Long.valueOf(eventMask.longValue() & ~(XConstants.FocusChangeMask | XConstants.KeyPressMask | XConstants.KeyReleaseMask)));
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    88
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
    89
90ce3da70b43 Initial load
duke
parents:
diff changeset
    90
    void postInit(XCreateWindowParams params) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    91
        super.postInit(params);
90ce3da70b43 Initial load
duke
parents:
diff changeset
    92
        // The lines that follow need to be in a postInit, so they
90ce3da70b43 Initial load
duke
parents:
diff changeset
    93
        // happen after the X window is created.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    94
        initResizability();
90ce3da70b43 Initial load
duke
parents:
diff changeset
    95
        updateSizeHints(dimensions);
449
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
    96
        XWM.requestWMExtents(getWindow());
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
    97
115
e270c597a3ad 6645885: small refactoring for XContentWindow
son
parents: 2
diff changeset
    98
        content = XContentWindow.createContent(this);
449
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
    99
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   100
        if (warningWindow != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   101
            warningWindow.toFront();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   102
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   103
        focusProxy = createFocusProxy();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   104
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   105
90ce3da70b43 Initial load
duke
parents:
diff changeset
   106
    void setIconHints(java.util.List<XIconInfo> icons) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   107
        if (!XWM.getWM().setNetWMIcon(this, icons)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   108
            if (icons.size() > 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   109
                if (iconWindow == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   110
                    iconWindow = new XIconWindow(this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   111
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   112
                iconWindow.setIconImages(icons);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   113
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   114
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   115
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   116
90ce3da70b43 Initial load
duke
parents:
diff changeset
   117
    public void updateMinimumSize() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   118
        super.updateMinimumSize();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   119
        updateMinSizeHints();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   120
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   121
90ce3da70b43 Initial load
duke
parents:
diff changeset
   122
    private void updateMinSizeHints() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   123
        if (isResizable()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   124
            Dimension minimumSize = getTargetMinimumSize();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   125
            if (minimumSize != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   126
                Insets insets = getRealInsets();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   127
                int minWidth = minimumSize.width - insets.left - insets.right;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   128
                int minHeight = minimumSize.height - insets.top - insets.bottom;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   129
                if (minWidth < 0) minWidth = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   130
                if (minHeight < 0) minHeight = 0;
439
3488710b02f8 6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents: 420
diff changeset
   131
                setSizeHints(XUtilConstants.PMinSize | (isLocationByPlatform()?0:(XUtilConstants.PPosition | XUtilConstants.USPosition)),
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   132
                             getX(), getY(), minWidth, minHeight);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   133
                if (isVisible()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   134
                    Rectangle bounds = getShellBounds();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   135
                    int nw = (bounds.width < minWidth) ? minWidth : bounds.width;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   136
                    int nh = (bounds.height < minHeight) ? minHeight : bounds.height;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   137
                    if (nw != bounds.width || nh != bounds.height) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   138
                        setShellSize(new Rectangle(0, 0, nw, nh));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   139
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   140
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   141
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   142
                boolean isMinSizeSet = isMinSizeSet();
439
3488710b02f8 6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents: 420
diff changeset
   143
                XWM.removeSizeHints(this, XUtilConstants.PMinSize);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   144
                /* Some WMs need remap to redecorate the window */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   145
                if (isMinSizeSet && isShowing() && XWM.needRemap(this)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   146
                    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   147
                     * Do the re/mapping at the Xlib level.  Since we essentially
90ce3da70b43 Initial load
duke
parents:
diff changeset
   148
                     * work around a WM bug we don't want this hack to be exposed
90ce3da70b43 Initial load
duke
parents:
diff changeset
   149
                     * to Intrinsics (i.e. don't mess with grabs, callbacks etc).
90ce3da70b43 Initial load
duke
parents:
diff changeset
   150
                     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   151
                    xSetVisible(false);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   152
                    XToolkit.XSync();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   153
                    xSetVisible(true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   154
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   155
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   156
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   157
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   158
90ce3da70b43 Initial load
duke
parents:
diff changeset
   159
    XFocusProxyWindow createFocusProxy() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   160
        return new XFocusProxyWindow(this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   161
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   162
90ce3da70b43 Initial load
duke
parents:
diff changeset
   163
    protected XAtomList getWMProtocols() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   164
        XAtomList protocols = super.getWMProtocols();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   165
        protocols.add(wm_delete_window);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   166
        protocols.add(wm_take_focus);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   167
        return protocols;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   168
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   169
90ce3da70b43 Initial load
duke
parents:
diff changeset
   170
    public Graphics getGraphics() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   171
        return getGraphics(content.surfaceData,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   172
                           ComponentAccessor.getForeground(target),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   173
                           ComponentAccessor.getBackground(target),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   174
                           ComponentAccessor.getFont_NoClientCode(target));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   175
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   176
90ce3da70b43 Initial load
duke
parents:
diff changeset
   177
    public void setTitle(String title) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   178
        if (log.isLoggable(Level.FINE)) log.fine("Title is " + title);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   179
        winAttr.title = title;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   180
        updateWMName();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   181
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   182
90ce3da70b43 Initial load
duke
parents:
diff changeset
   183
    protected String getWMName() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   184
        if (winAttr.title == null || winAttr.title.trim().equals("")) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   185
            return " ";
90ce3da70b43 Initial load
duke
parents:
diff changeset
   186
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   187
            return winAttr.title;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   188
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   189
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   190
90ce3da70b43 Initial load
duke
parents:
diff changeset
   191
    void updateWMName() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   192
        super.updateWMName();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   193
        String name = getWMName();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   194
        XToolkit.awtLock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   195
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   196
            if (name == null || name.trim().equals("")) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   197
                name = "Java";
90ce3da70b43 Initial load
duke
parents:
diff changeset
   198
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   199
            XAtom iconNameAtom = XAtom.get(XAtom.XA_WM_ICON_NAME);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   200
            iconNameAtom.setProperty(getWindow(), name);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   201
            XAtom netIconNameAtom = XAtom.get("_NET_WM_ICON_NAME");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   202
            netIconNameAtom.setPropertyUTF8(getWindow(), name);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   203
        } finally {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   204
            XToolkit.awtUnlock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   205
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   206
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   207
90ce3da70b43 Initial load
duke
parents:
diff changeset
   208
    // NOTE: This method may be called by privileged threads.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   209
    //       DO NOT INVOKE CLIENT CODE ON THIS THREAD!
90ce3da70b43 Initial load
duke
parents:
diff changeset
   210
    public void handleIconify() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   211
        postEvent(new WindowEvent((Window)target, WindowEvent.WINDOW_ICONIFIED));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   212
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   213
90ce3da70b43 Initial load
duke
parents:
diff changeset
   214
    // NOTE: This method may be called by privileged threads.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   215
    //       DO NOT INVOKE CLIENT CODE ON THIS THREAD!
90ce3da70b43 Initial load
duke
parents:
diff changeset
   216
    public void handleDeiconify() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   217
        postEvent(new WindowEvent((Window)target, WindowEvent.WINDOW_DEICONIFIED));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   218
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   219
90ce3da70b43 Initial load
duke
parents:
diff changeset
   220
    public void handleFocusEvent(XEvent xev) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   221
        super.handleFocusEvent(xev);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   222
        XFocusChangeEvent xfe = xev.get_xfocus();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   223
90ce3da70b43 Initial load
duke
parents:
diff changeset
   224
        // If we somehow received focus events forward it instead to proxy
90ce3da70b43 Initial load
duke
parents:
diff changeset
   225
        // FIXME: Shouldn't we instead check for inferrior?
90ce3da70b43 Initial load
duke
parents:
diff changeset
   226
        focusLog.finer("Received focus event on shell: " + xfe);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   227
//         focusProxy.xRequestFocus();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   228
   }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   229
90ce3da70b43 Initial load
duke
parents:
diff changeset
   230
/***************************************************************************************
90ce3da70b43 Initial load
duke
parents:
diff changeset
   231
 *                             I N S E T S   C O D E
90ce3da70b43 Initial load
duke
parents:
diff changeset
   232
 **************************************************************************************/
90ce3da70b43 Initial load
duke
parents:
diff changeset
   233
90ce3da70b43 Initial load
duke
parents:
diff changeset
   234
    protected boolean isInitialReshape() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   235
        return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   236
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   237
449
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   238
    private static Insets difference(Insets i1, Insets i2) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   239
        return new Insets(i1.top-i2.top, i1.left - i2.left, i1.bottom-i2.bottom, i1.right-i2.right);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   240
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   241
449
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   242
    private static boolean isNull(Insets i) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   243
        return (i == null) || ((i.left | i.top | i.right | i.bottom) == 0);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   244
    }
449
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   245
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   246
    private static Insets copy(Insets i) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   247
        return new Insets(i.top, i.left, i.bottom, i.right);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   248
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   249
449
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   250
    // insets which we get from WM (e.g from _NET_FRAME_EXTENTS)
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   251
    private Insets wm_set_insets;
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   252
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   253
    private Insets getWMSetInsets(XAtom changedAtom) {
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   254
        if (isEmbedded()) {
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   255
            return null;
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   256
        }
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   257
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   258
        if (wm_set_insets != null) {
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   259
            return wm_set_insets;
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   260
        }
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   261
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   262
        if (changedAtom == null) {
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   263
            wm_set_insets = XWM.getInsetsFromExtents(getWindow());
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   264
        } else {
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   265
            wm_set_insets = XWM.getInsetsFromProp(getWindow(), changedAtom);
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   266
        }
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   267
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   268
        insLog.log(Level.FINER, "FRAME_EXTENTS: {0}", new Object[]{wm_set_insets});
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   269
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   270
        if (wm_set_insets != null) {
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   271
            wm_set_insets = copy(wm_set_insets);
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   272
        }
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   273
        return wm_set_insets;
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   274
    }
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   275
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   276
    private void resetWMSetInsets() {
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   277
        wm_set_insets = null;
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   278
    }
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   279
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   280
    public void handlePropertyNotify(XEvent xev) {
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   281
        super.handlePropertyNotify(xev);
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   282
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   283
        XPropertyEvent ev = xev.get_xproperty();
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   284
        if (ev.get_atom() == XWM.XA_KDE_NET_WM_FRAME_STRUT.getAtom()
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   285
            || ev.get_atom() == XWM.XA_NET_FRAME_EXTENTS.getAtom())
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   286
        {
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   287
            getWMSetInsets(XAtom.get(ev.get_atom()));
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   288
        }
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   289
    }
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   290
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   291
    long reparent_serial = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   292
90ce3da70b43 Initial load
duke
parents:
diff changeset
   293
    public void handleReparentNotifyEvent(XEvent xev) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   294
        XReparentEvent  xe = xev.get_xreparent();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   295
        if (insLog.isLoggable(Level.FINE)) insLog.fine(xe.toString());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   296
        reparent_serial = xe.get_serial();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   297
        XToolkit.awtLock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   298
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   299
            long root = XlibWrapper.RootWindow(XToolkit.getDisplay(), getScreenNumber());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   300
90ce3da70b43 Initial load
duke
parents:
diff changeset
   301
            if (isEmbedded()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   302
                setReparented(true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   303
                insets_corrected = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   304
                return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   305
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   306
            Component t = (Component)target;
115
e270c597a3ad 6645885: small refactoring for XContentWindow
son
parents: 2
diff changeset
   307
            if (getDecorations() == XWindowAttributesData.AWT_DECOR_NONE) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   308
                setReparented(true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   309
                insets_corrected = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   310
                reshape(dimensions, SET_SIZE, false);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   311
            } else if (xe.get_parent() == root) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   312
                configure_seen = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   313
                insets_corrected = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   314
90ce3da70b43 Initial load
duke
parents:
diff changeset
   315
                /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   316
                 * We can be repareted to root for two reasons:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   317
                 *   . setVisible(false)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   318
                 *   . WM exited
90ce3da70b43 Initial load
duke
parents:
diff changeset
   319
                 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   320
                if (isVisible()) { /* WM exited */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   321
                    /* Work around 4775545 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   322
                    XWM.getWM().unshadeKludge(this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   323
                    insLog.fine("- WM exited");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   324
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   325
                    insLog.fine(" - reparent due to hide");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   326
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   327
            } else { /* reparented to WM frame, figure out our insets */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   328
                setReparented(true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   329
                insets_corrected = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   330
90ce3da70b43 Initial load
duke
parents:
diff changeset
   331
                // Check if we have insets provided by the WM
90ce3da70b43 Initial load
duke
parents:
diff changeset
   332
                Insets correctWM = getWMSetInsets(null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   333
                if (correctWM != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   334
                    insLog.log(Level.FINER, "wm-provided insets {0}", new Object[]{correctWM});
90ce3da70b43 Initial load
duke
parents:
diff changeset
   335
                    // If these insets are equal to our current insets - no actions are necessary
90ce3da70b43 Initial load
duke
parents:
diff changeset
   336
                    Insets dimInsets = dimensions.getInsets();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   337
                    if (correctWM.equals(dimInsets)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   338
                        insLog.finer("Insets are the same as estimated - no additional reshapes necessary");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   339
                        no_reparent_artifacts = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   340
                        insets_corrected = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   341
                        applyGuessedInsets();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   342
                        return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   343
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   344
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   345
                    correctWM = XWM.getWM().getInsets(this, xe.get_window(), xe.get_parent());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   346
90ce3da70b43 Initial load
duke
parents:
diff changeset
   347
                    if (correctWM != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   348
                        insLog.log(Level.FINER, "correctWM {0}", new Object[] {correctWM});
90ce3da70b43 Initial load
duke
parents:
diff changeset
   349
                    } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   350
                        insLog.log(Level.FINER, "correctWM insets are not available, waiting for configureNotify");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   351
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   352
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   353
90ce3da70b43 Initial load
duke
parents:
diff changeset
   354
                if (correctWM != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   355
                    handleCorrectInsets(correctWM);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   356
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   357
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   358
        } finally {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   359
            XToolkit.awtUnlock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   360
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   361
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   362
90ce3da70b43 Initial load
duke
parents:
diff changeset
   363
    protected void handleCorrectInsets(Insets correctWM) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   364
        XToolkit.awtLock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   365
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   366
            /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   367
             * Ok, now see if we need adjust window size because
90ce3da70b43 Initial load
duke
parents:
diff changeset
   368
             * initial insets were wrong (most likely they were).
90ce3da70b43 Initial load
duke
parents:
diff changeset
   369
             */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   370
            Insets correction = difference(correctWM, currentInsets);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   371
            insLog.log(Level.FINEST, "Corrention {0}", new Object[] {correction});
90ce3da70b43 Initial load
duke
parents:
diff changeset
   372
            if (!isNull(correction)) {
449
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   373
                currentInsets = copy(correctWM);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   374
                applyGuessedInsets();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   375
90ce3da70b43 Initial load
duke
parents:
diff changeset
   376
                //Fix for 6318109: PIT: Min Size is not honored properly when a
90ce3da70b43 Initial load
duke
parents:
diff changeset
   377
                //smaller size is specified in setSize(), XToolkit
90ce3da70b43 Initial load
duke
parents:
diff changeset
   378
                //update minimum size hints
90ce3da70b43 Initial load
duke
parents:
diff changeset
   379
                updateMinSizeHints();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   380
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   381
            if (insLog.isLoggable(Level.FINER)) insLog.finer("Dimensions before reparent: " + dimensions);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   382
90ce3da70b43 Initial load
duke
parents:
diff changeset
   383
            dimensions.setInsets(getRealInsets());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   384
            insets_corrected = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   385
449
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   386
            if (isMaximized() || isNull(correction)) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   387
                return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   388
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   389
449
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   390
            /*
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   391
             * If this window has been sized by a pack() we need
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   392
             * to keep the interior geometry intact.  Since pack()
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   393
             * computed width and height with wrong insets, we
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   394
             * must adjust the target dimensions appropriately.
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   395
             */
439
3488710b02f8 6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents: 420
diff changeset
   396
            if ((getHints().get_flags() & (XUtilConstants.USPosition | XUtilConstants.PPosition)) != 0) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   397
                reshape(dimensions, SET_BOUNDS, false);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   398
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   399
                reshape(dimensions, SET_SIZE, false);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   400
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   401
        } finally {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   402
            XToolkit.awtUnlock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   403
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   404
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   405
90ce3da70b43 Initial load
duke
parents:
diff changeset
   406
    public void handleMoved(WindowDimensions dims) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   407
        Point loc = dims.getLocation();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   408
        ComponentAccessor.setX((Component)target, loc.x);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   409
        ComponentAccessor.setY((Component)target, loc.y);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   410
        postEvent(new ComponentEvent(target, ComponentEvent.COMPONENT_MOVED));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   411
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   412
90ce3da70b43 Initial load
duke
parents:
diff changeset
   413
90ce3da70b43 Initial load
duke
parents:
diff changeset
   414
    protected Insets guessInsets() {
449
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   415
        if (isEmbedded() || isTargetUndecorated()) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   416
            return new Insets(0, 0, 0, 0);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   417
        } else {
449
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   418
            if (!isNull(currentInsets)) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   419
                /* insets were set on wdata by System Properties */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   420
                return copy(currentInsets);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   421
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   422
                Insets res = getWMSetInsets(null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   423
                if (res == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   424
                    res = XWM.getWM().guessInsets(this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   425
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   426
                return res;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   427
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   428
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   429
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   430
90ce3da70b43 Initial load
duke
parents:
diff changeset
   431
    private void applyGuessedInsets() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   432
        Insets guessed = guessInsets();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   433
        currentInsets = copy(guessed);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   434
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   435
90ce3da70b43 Initial load
duke
parents:
diff changeset
   436
    public void revalidate() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   437
        XToolkit.executeOnEventHandlerThread(target, new Runnable() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   438
                public void run() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   439
                    target.invalidate();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   440
                    target.validate();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   441
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   442
            });
90ce3da70b43 Initial load
duke
parents:
diff changeset
   443
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   444
90ce3da70b43 Initial load
duke
parents:
diff changeset
   445
    Insets getRealInsets() {
449
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   446
        if (isNull(currentInsets)) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   447
            applyGuessedInsets();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   448
        }
449
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   449
        return currentInsets;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   450
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   451
90ce3da70b43 Initial load
duke
parents:
diff changeset
   452
    public Insets getInsets() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   453
        Insets in = copy(getRealInsets());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   454
        in.top += getMenuBarHeight() + getWarningWindowHeight();
449
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   455
        if (insLog.isLoggable(Level.FINEST)) {
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   456
            insLog.log(Level.FINEST, "Get insets returns {0}", new Object[] {in});
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   457
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   458
        return in;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   459
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   460
90ce3da70b43 Initial load
duke
parents:
diff changeset
   461
    boolean gravityBug() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   462
        return XWM.configureGravityBuggy();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   463
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   464
90ce3da70b43 Initial load
duke
parents:
diff changeset
   465
    // The height of area used to display current active input method
90ce3da70b43 Initial load
duke
parents:
diff changeset
   466
    int getInputMethodHeight() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   467
        return 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   468
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   469
90ce3da70b43 Initial load
duke
parents:
diff changeset
   470
    void updateSizeHints(WindowDimensions dims) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   471
        Rectangle rec = dims.getClientRect();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   472
        checkShellRect(rec);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   473
        updateSizeHints(rec.x, rec.y, rec.width, rec.height);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   474
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   475
90ce3da70b43 Initial load
duke
parents:
diff changeset
   476
    void updateSizeHints() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   477
        updateSizeHints(dimensions);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   478
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   479
90ce3da70b43 Initial load
duke
parents:
diff changeset
   480
    // Coordinates are that of the target
90ce3da70b43 Initial load
duke
parents:
diff changeset
   481
    // Called only on Toolkit thread
90ce3da70b43 Initial load
duke
parents:
diff changeset
   482
    public void reshape(WindowDimensions newDimensions, int op,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   483
                        boolean userReshape)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   484
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   485
        if (insLog.isLoggable(Level.FINE)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   486
            insLog.fine("Reshaping " + this + " to " + newDimensions + " op " + op + " user reshape " + userReshape);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   487
        }
129
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   488
        if (userReshape) {
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   489
            // We handle only userReshape == true cases. It means that
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   490
            // if the window manager or any other part of the windowing
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   491
            // system sets inappropriate size for this window, we can
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   492
            // do nothing but accept it.
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   493
            Rectangle reqBounds = newDimensions.getBounds();
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   494
            Rectangle newBounds = constrainBounds(reqBounds.x, reqBounds.y, reqBounds.width, reqBounds.height);
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   495
            newDimensions = new WindowDimensions(newBounds, newDimensions.getInsets(), newDimensions.isClientSizeSet());
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   496
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   497
        XToolkit.awtLock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   498
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   499
            if (!isReparented() || !isVisible()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   500
                insLog.log(Level.FINE, "- not reparented({0}) or not visible({1}), default reshape",
90ce3da70b43 Initial load
duke
parents:
diff changeset
   501
                           new Object[] {Boolean.valueOf(isReparented()), Boolean.valueOf(visible)});
90ce3da70b43 Initial load
duke
parents:
diff changeset
   502
90ce3da70b43 Initial load
duke
parents:
diff changeset
   503
                // Fix for 6323293.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   504
                // This actually is needed to preserve compatibility with previous releases -
90ce3da70b43 Initial load
duke
parents:
diff changeset
   505
                // some of licensees are expecting componentMoved event on invisible one while
90ce3da70b43 Initial load
duke
parents:
diff changeset
   506
                // its location changes.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   507
                Point oldLocation = getLocation();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   508
90ce3da70b43 Initial load
duke
parents:
diff changeset
   509
                Point newLocation = new Point(ComponentAccessor.getX((Component)target),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   510
                                              ComponentAccessor.getY((Component)target));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   511
90ce3da70b43 Initial load
duke
parents:
diff changeset
   512
                if (!newLocation.equals(oldLocation)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   513
                    handleMoved(newDimensions);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   514
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   515
90ce3da70b43 Initial load
duke
parents:
diff changeset
   516
                dimensions = new WindowDimensions(newDimensions);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   517
                updateSizeHints(dimensions);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   518
                Rectangle client = dimensions.getClientRect();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   519
                checkShellRect(client);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   520
                setShellBounds(client);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   521
                if (content != null &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
   522
                    !content.getSize().equals(newDimensions.getSize()))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   523
                {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   524
                    reconfigureContentWindow(newDimensions);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   525
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   526
                return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   527
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   528
90ce3da70b43 Initial load
duke
parents:
diff changeset
   529
            int wm = XWM.getWMID();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   530
            updateChildrenSizes();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   531
            applyGuessedInsets();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   532
90ce3da70b43 Initial load
duke
parents:
diff changeset
   533
            Rectangle shellRect = newDimensions.getClientRect();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   534
90ce3da70b43 Initial load
duke
parents:
diff changeset
   535
            if (gravityBug()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   536
                Insets in = newDimensions.getInsets();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   537
                shellRect.translate(in.left, in.top);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   538
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   539
90ce3da70b43 Initial load
duke
parents:
diff changeset
   540
            if ((op & NO_EMBEDDED_CHECK) == 0 && isEmbedded()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   541
                shellRect.setLocation(0, 0);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   542
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   543
90ce3da70b43 Initial load
duke
parents:
diff changeset
   544
            checkShellRectSize(shellRect);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   545
            if (!isEmbedded()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   546
                checkShellRectPos(shellRect);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   547
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   548
90ce3da70b43 Initial load
duke
parents:
diff changeset
   549
            op = op & ~NO_EMBEDDED_CHECK;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   550
90ce3da70b43 Initial load
duke
parents:
diff changeset
   551
            if (op == SET_LOCATION) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   552
                setShellPosition(shellRect);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   553
            } else if (isResizable()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   554
                if (op == SET_BOUNDS) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   555
                    setShellBounds(shellRect);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   556
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   557
                    setShellSize(shellRect);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   558
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   559
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   560
                XWM.setShellNotResizable(this, newDimensions, shellRect, true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   561
                if (op == SET_BOUNDS) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   562
                    setShellPosition(shellRect);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   563
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   564
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   565
90ce3da70b43 Initial load
duke
parents:
diff changeset
   566
            reconfigureContentWindow(newDimensions);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   567
        } finally {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   568
            XToolkit.awtUnlock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   569
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   570
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   571
90ce3da70b43 Initial load
duke
parents:
diff changeset
   572
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   573
     * @param x, y, width, heith - dimensions of the window with insets
90ce3da70b43 Initial load
duke
parents:
diff changeset
   574
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   575
    private void reshape(int x, int y, int width, int height, int operation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   576
                         boolean userReshape)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   577
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   578
        Rectangle newRec;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   579
        boolean setClient = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   580
        WindowDimensions dims = new WindowDimensions(dimensions);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   581
        switch (operation & (~NO_EMBEDDED_CHECK)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   582
          case SET_LOCATION:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   583
              // Set location always sets bounds location. However, until the window is mapped we
90ce3da70b43 Initial load
duke
parents:
diff changeset
   584
              // should use client coordinates
90ce3da70b43 Initial load
duke
parents:
diff changeset
   585
              dims.setLocation(x, y);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   586
              break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   587
          case SET_SIZE:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   588
              // Set size sets bounds size. However, until the window is mapped we
90ce3da70b43 Initial load
duke
parents:
diff changeset
   589
              // should use client coordinates
90ce3da70b43 Initial load
duke
parents:
diff changeset
   590
              dims.setSize(width, height);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   591
              break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   592
          case SET_CLIENT_SIZE: {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   593
              // Sets client rect size. Width and height contain insets.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   594
              Insets in = currentInsets;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   595
              width -= in.left+in.right;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   596
              height -= in.top+in.bottom;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   597
              dims.setClientSize(width, height);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   598
              break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   599
          }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   600
          case SET_BOUNDS:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   601
          default:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   602
              dims.setLocation(x, y);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   603
              dims.setSize(width, height);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   604
              break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   605
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   606
        if (insLog.isLoggable(Level.FINE)) insLog.log(Level.FINE, "For the operation {0} new dimensions are {1}",
90ce3da70b43 Initial load
duke
parents:
diff changeset
   607
                                                      new Object[] {operationToString(operation), dims});
90ce3da70b43 Initial load
duke
parents:
diff changeset
   608
90ce3da70b43 Initial load
duke
parents:
diff changeset
   609
        reshape(dims, operation, userReshape);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   610
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   611
129
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   612
    // This method gets overriden in XFramePeer & XDialogPeer.
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   613
    abstract boolean isTargetUndecorated();
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   614
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   615
    @Override
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   616
    Rectangle constrainBounds(int x, int y, int width, int height) {
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   617
        // We don't restrict the setBounds() operation if the code is trusted.
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   618
        if (!hasWarningWindow()) {
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   619
            return new Rectangle(x, y, width, height);
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   620
        }
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   621
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   622
        // If it's undecorated or is not currently visible,
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   623
        // apply the same constraints as for the Window.
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   624
        if (!isVisible() || isTargetUndecorated()) {
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   625
            return super.constrainBounds(x, y, width, height);
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   626
        }
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   627
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   628
        // If it's visible & decorated, constraint the size only
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   629
        int newX = x;
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   630
        int newY = y;
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   631
        int newW = width;
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   632
        int newH = height;
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   633
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   634
        GraphicsConfiguration gc = ((Window)target).getGraphicsConfiguration();
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   635
        Rectangle sB = gc.getBounds();
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   636
        Insets sIn = ((Window)target).getToolkit().getScreenInsets(gc);
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   637
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   638
        Rectangle curBounds = getBounds();
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   639
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   640
        int maxW = Math.max(sB.width - sIn.left - sIn.right, curBounds.width);
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   641
        int maxH = Math.max(sB.height - sIn.top - sIn.bottom, curBounds.height);
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   642
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   643
        // First make sure the size is withing the visible part of the screen
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   644
        if (newW > maxW) {
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   645
            newW = maxW;
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   646
        }
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   647
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   648
        if (newH > maxH) {
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   649
            newH = maxH;
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   650
        }
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   651
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   652
        return new Rectangle(newX, newY, newW, newH);
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   653
    }
f995b9c9c5fa 6589527: Window and Frame instances can hide their "Applet Warning"
anthony
parents: 118
diff changeset
   654
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   655
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   656
     * @see java.awt.peer.ComponentPeer#setBounds
90ce3da70b43 Initial load
duke
parents:
diff changeset
   657
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   658
    public void setBounds(int x, int y, int width, int height, int op) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   659
        // TODO: Rewrite with WindowDimensions
90ce3da70b43 Initial load
duke
parents:
diff changeset
   660
        reshape(x, y, width, height, op, true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   661
        validateSurface();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   662
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   663
90ce3da70b43 Initial load
duke
parents:
diff changeset
   664
    // Coordinates are that of the shell
90ce3da70b43 Initial load
duke
parents:
diff changeset
   665
    void reconfigureContentWindow(WindowDimensions dims) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   666
        if (content == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   667
            insLog.fine("WARNING: Content window is null");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   668
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   669
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   670
        content.setContentBounds(dims);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   671
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   672
90ce3da70b43 Initial load
duke
parents:
diff changeset
   673
    boolean no_reparent_artifacts = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   674
    public void handleConfigureNotifyEvent(XEvent xev) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   675
        assert (SunToolkit.isAWTLockHeldByCurrentThread());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   676
        XConfigureEvent xe = xev.get_xconfigure();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   677
        insLog.log(Level.FINE, "Configure notify {0}", new Object[] {xe});
90ce3da70b43 Initial load
duke
parents:
diff changeset
   678
90ce3da70b43 Initial load
duke
parents:
diff changeset
   679
        // XXX: should really only consider synthetic events, but
90ce3da70b43 Initial load
duke
parents:
diff changeset
   680
        if (isReparented()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   681
            configure_seen = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   682
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   683
90ce3da70b43 Initial load
duke
parents:
diff changeset
   684
        if (!isMaximized()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   685
            && (xe.get_serial() == reparent_serial || xe.get_window() != getShell())
90ce3da70b43 Initial load
duke
parents:
diff changeset
   686
            && !no_reparent_artifacts)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   687
        {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   688
            insLog.fine("- reparent artifact, skipping");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   689
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   690
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   691
        no_reparent_artifacts = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   692
90ce3da70b43 Initial load
duke
parents:
diff changeset
   693
        /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   694
         * When there is a WM we receive some CN before being visible and after.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   695
         * We should skip all CN which are before being visible, because we assume
90ce3da70b43 Initial load
duke
parents:
diff changeset
   696
         * the gravity is in action while it is not yet.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   697
         *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   698
         * When there is no WM we receive CN only _before_ being visible.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   699
         * We should process these CNs.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   700
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   701
        if (!isVisible() && XWM.getWMID() != XWM.NO_WM) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   702
            insLog.fine(" - not visible, skipping");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   703
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   704
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   705
90ce3da70b43 Initial load
duke
parents:
diff changeset
   706
        /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   707
         * Some window managers configure before we are reparented and
90ce3da70b43 Initial load
duke
parents:
diff changeset
   708
         * the send event flag is set! ugh... (Enlighetenment for one,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   709
         * possibly MWM as well).  If we haven't been reparented yet
90ce3da70b43 Initial load
duke
parents:
diff changeset
   710
         * this is just the WM shuffling us into position.  Ignore
90ce3da70b43 Initial load
duke
parents:
diff changeset
   711
         * it!!!! or we wind up in a bogus location.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   712
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   713
        int runningWM = XWM.getWMID();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   714
        if (insLog.isLoggable(Level.FINE)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   715
            insLog.log(Level.FINE, "reparented={0}, visible={1}, WM={2}, decorations={3}",
90ce3da70b43 Initial load
duke
parents:
diff changeset
   716
                    new Object[] {isReparented(), isVisible(), runningWM, getDecorations()});
90ce3da70b43 Initial load
duke
parents:
diff changeset
   717
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   718
        if (!isReparented() && isVisible() && runningWM != XWM.NO_WM
90ce3da70b43 Initial load
duke
parents:
diff changeset
   719
                &&  !XWM.isNonReparentingWM()
115
e270c597a3ad 6645885: small refactoring for XContentWindow
son
parents: 2
diff changeset
   720
                && getDecorations() != XWindowAttributesData.AWT_DECOR_NONE) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   721
            insLog.fine("- visible but not reparented, skipping");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   722
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   723
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   724
        //Last chance to correct insets
115
e270c597a3ad 6645885: small refactoring for XContentWindow
son
parents: 2
diff changeset
   725
        if (!insets_corrected && getDecorations() != XWindowAttributesData.AWT_DECOR_NONE) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   726
            long parent = XlibUtil.getParentWindow(window);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   727
            Insets correctWM = (parent != -1) ? XWM.getWM().getInsets(this, window, parent) : null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   728
            if (insLog.isLoggable(Level.FINER)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   729
                if (correctWM != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   730
                    insLog.finer("Configure notify - insets : " + correctWM);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   731
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   732
                    insLog.finer("Configure notify - insets are still not available");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   733
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   734
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   735
            if (correctWM != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   736
                handleCorrectInsets(correctWM);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   737
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   738
                //Only one attempt to correct insets is made (to lower risk)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   739
                //if insets are still not available we simply set the flag
90ce3da70b43 Initial load
duke
parents:
diff changeset
   740
                insets_corrected = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   741
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   742
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   743
90ce3da70b43 Initial load
duke
parents:
diff changeset
   744
        updateChildrenSizes();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   745
90ce3da70b43 Initial load
duke
parents:
diff changeset
   746
        // Bounds of the window
90ce3da70b43 Initial load
duke
parents:
diff changeset
   747
        Rectangle targetBounds = new Rectangle(ComponentAccessor.getX((Component)target),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   748
                ComponentAccessor.getY((Component)target),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   749
                ComponentAccessor.getWidth((Component)target),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   750
                ComponentAccessor.getHeight((Component)target));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   751
90ce3da70b43 Initial load
duke
parents:
diff changeset
   752
        Point newLocation = targetBounds.getLocation();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   753
        if (xe.get_send_event() || runningWM == XWM.NO_WM || XWM.isNonReparentingWM()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   754
            // Location, Client size + insets
90ce3da70b43 Initial load
duke
parents:
diff changeset
   755
            newLocation = new Point(xe.get_x() - currentInsets.left, xe.get_y() - currentInsets.top);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   756
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   757
            // CDE/MWM/Metacity/Sawfish bug: if shell is resized using
90ce3da70b43 Initial load
duke
parents:
diff changeset
   758
            // top or left border, we don't receive synthetic
90ce3da70b43 Initial load
duke
parents:
diff changeset
   759
            // ConfigureNotify, only the one from X with zero
90ce3da70b43 Initial load
duke
parents:
diff changeset
   760
            // coordinates.  This is the workaround to get real
90ce3da70b43 Initial load
duke
parents:
diff changeset
   761
            // location, 6261336
90ce3da70b43 Initial load
duke
parents:
diff changeset
   762
            switch (XWM.getWMID()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   763
                case XWM.CDE_WM:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   764
                case XWM.MOTIF_WM:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   765
                case XWM.METACITY_WM:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   766
                case XWM.SAWFISH_WM:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   767
                {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   768
                    Point xlocation = queryXLocation();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   769
                    if (log.isLoggable(Level.FINE)) log.log(Level.FINE, "New X location: {0}", new Object[]{xlocation});
90ce3da70b43 Initial load
duke
parents:
diff changeset
   770
                    if (xlocation != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   771
                        newLocation = xlocation;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   772
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   773
                    break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   774
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   775
                default:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   776
                    break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   777
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   778
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   779
90ce3da70b43 Initial load
duke
parents:
diff changeset
   780
        WindowDimensions newDimensions =
90ce3da70b43 Initial load
duke
parents:
diff changeset
   781
                new WindowDimensions(newLocation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   782
                new Dimension(xe.get_width(), xe.get_height()),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   783
                copy(currentInsets),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   784
                true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   785
90ce3da70b43 Initial load
duke
parents:
diff changeset
   786
        insLog.log(Level.FINER, "Insets are {0}, new dimensions {1}",
90ce3da70b43 Initial load
duke
parents:
diff changeset
   787
                new Object[] {currentInsets, newDimensions});
90ce3da70b43 Initial load
duke
parents:
diff changeset
   788
90ce3da70b43 Initial load
duke
parents:
diff changeset
   789
        checkIfOnNewScreen(newDimensions.getBounds());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   790
90ce3da70b43 Initial load
duke
parents:
diff changeset
   791
        Point oldLocation = getLocation();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   792
        dimensions = newDimensions;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   793
        if (!newLocation.equals(oldLocation)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   794
            handleMoved(newDimensions);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   795
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   796
        reconfigureContentWindow(newDimensions);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   797
        updateChildrenSizes();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   798
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   799
90ce3da70b43 Initial load
duke
parents:
diff changeset
   800
    private void checkShellRectSize(Rectangle shellRect) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   801
        if (shellRect.width < 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   802
            shellRect.width = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   803
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   804
        if (shellRect.height < 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   805
            shellRect.height = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   806
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   807
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   808
90ce3da70b43 Initial load
duke
parents:
diff changeset
   809
    private void checkShellRectPos(Rectangle shellRect) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   810
        int wm = XWM.getWMID();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   811
        if (wm == XWM.MOTIF_WM || wm == XWM.CDE_WM) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   812
            if (shellRect.x == 0 && shellRect.y == 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   813
                shellRect.x = shellRect.y = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   814
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   815
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   816
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   817
90ce3da70b43 Initial load
duke
parents:
diff changeset
   818
    private void checkShellRect(Rectangle shellRect) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   819
        checkShellRectSize(shellRect);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   820
        checkShellRectPos(shellRect);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   821
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   822
90ce3da70b43 Initial load
duke
parents:
diff changeset
   823
    public void setShellBounds(Rectangle rec) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   824
        if (insLog.isLoggable(Level.FINE)) insLog.fine("Setting shell bounds on " +
90ce3da70b43 Initial load
duke
parents:
diff changeset
   825
                                                       this + " to " + rec);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   826
        XToolkit.awtLock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   827
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   828
            updateSizeHints(rec.x, rec.y, rec.width, rec.height);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   829
            XlibWrapper.XResizeWindow(XToolkit.getDisplay(), getShell(), rec.width, rec.height);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   830
            XlibWrapper.XMoveWindow(XToolkit.getDisplay(), getShell(), rec.x, rec.y);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   831
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   832
        finally {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   833
            XToolkit.awtUnlock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   834
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   835
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   836
    public void setShellSize(Rectangle rec) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   837
        if (insLog.isLoggable(Level.FINE)) insLog.fine("Setting shell size on " +
90ce3da70b43 Initial load
duke
parents:
diff changeset
   838
                                                       this + " to " + rec);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   839
        XToolkit.awtLock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   840
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   841
            updateSizeHints(rec.x, rec.y, rec.width, rec.height);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   842
            XlibWrapper.XResizeWindow(XToolkit.getDisplay(), getShell(), rec.width, rec.height);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   843
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   844
        finally {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   845
            XToolkit.awtUnlock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   846
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   847
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   848
    public void setShellPosition(Rectangle rec) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   849
        if (insLog.isLoggable(Level.FINE)) insLog.fine("Setting shell position on " +
90ce3da70b43 Initial load
duke
parents:
diff changeset
   850
                                                       this + " to " + rec);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   851
        XToolkit.awtLock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   852
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   853
            updateSizeHints(rec.x, rec.y, rec.width, rec.height);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   854
            XlibWrapper.XMoveWindow(XToolkit.getDisplay(), getShell(), rec.x, rec.y);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   855
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   856
        finally {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   857
            XToolkit.awtUnlock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   858
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   859
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   860
90ce3da70b43 Initial load
duke
parents:
diff changeset
   861
    void initResizability() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   862
        setResizable(winAttr.initialResizability);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   863
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   864
    public void setResizable(boolean resizable) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   865
        int fs = winAttr.functions;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   866
        if (!isResizable() && resizable) {
449
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   867
            currentInsets = new Insets(0, 0, 0, 0);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   868
            resetWMSetInsets();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   869
            if (!isEmbedded()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   870
                setReparented(false);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   871
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   872
            winAttr.isResizable = resizable;
439
3488710b02f8 6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents: 420
diff changeset
   873
            if ((fs & MWMConstants.MWM_FUNC_ALL) != 0) {
3488710b02f8 6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents: 420
diff changeset
   874
                fs &= ~(MWMConstants.MWM_FUNC_RESIZE | MWMConstants.MWM_FUNC_MAXIMIZE);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   875
            } else {
439
3488710b02f8 6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents: 420
diff changeset
   876
                fs |= (MWMConstants.MWM_FUNC_RESIZE | MWMConstants.MWM_FUNC_MAXIMIZE);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   877
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   878
            winAttr.functions = fs;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   879
            XWM.setShellResizable(this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   880
        } else if (isResizable() && !resizable) {
449
7820f232278d 6690036: some code cleanup for insets-related code
son
parents: 442
diff changeset
   881
            currentInsets = new Insets(0, 0, 0, 0);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   882
            resetWMSetInsets();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   883
            if (!isEmbedded()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   884
                setReparented(false);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   885
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   886
            winAttr.isResizable = resizable;
439
3488710b02f8 6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents: 420
diff changeset
   887
            if ((fs & MWMConstants.MWM_FUNC_ALL) != 0) {
3488710b02f8 6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents: 420
diff changeset
   888
                fs |= (MWMConstants.MWM_FUNC_RESIZE | MWMConstants.MWM_FUNC_MAXIMIZE);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   889
            } else {
439
3488710b02f8 6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents: 420
diff changeset
   890
                fs &= ~(MWMConstants.MWM_FUNC_RESIZE | MWMConstants.MWM_FUNC_MAXIMIZE);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   891
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   892
            winAttr.functions = fs;
118
35b334a806ab 6522731: Location of the frame changes,when the frame is resized & non-resized.
dcherepanov
parents: 115
diff changeset
   893
            XWM.setShellNotResizable(this, dimensions, dimensions.getBounds(), false);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   894
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   895
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   896
90ce3da70b43 Initial load
duke
parents:
diff changeset
   897
    Rectangle getShellBounds() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   898
        return dimensions.getClientRect();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   899
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   900
90ce3da70b43 Initial load
duke
parents:
diff changeset
   901
    public Rectangle getBounds() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   902
        return dimensions.getBounds();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   903
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   904
90ce3da70b43 Initial load
duke
parents:
diff changeset
   905
    public Dimension getSize() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   906
        return dimensions.getSize();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   907
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   908
90ce3da70b43 Initial load
duke
parents:
diff changeset
   909
    public int getX() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   910
        return dimensions.getLocation().x;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   911
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   912
90ce3da70b43 Initial load
duke
parents:
diff changeset
   913
    public int getY() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   914
        return dimensions.getLocation().y;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   915
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   916
90ce3da70b43 Initial load
duke
parents:
diff changeset
   917
    public Point getLocation() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   918
        return dimensions.getLocation();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   919
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   920
90ce3da70b43 Initial load
duke
parents:
diff changeset
   921
    public int getAbsoluteX() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   922
        // NOTE: returning this peer's location which is shell location
90ce3da70b43 Initial load
duke
parents:
diff changeset
   923
        return dimensions.getScreenBounds().x;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   924
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   925
90ce3da70b43 Initial load
duke
parents:
diff changeset
   926
    public int getAbsoluteY() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   927
        // NOTE: returning this peer's location which is shell location
90ce3da70b43 Initial load
duke
parents:
diff changeset
   928
        return dimensions.getScreenBounds().y;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   929
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   930
90ce3da70b43 Initial load
duke
parents:
diff changeset
   931
    public int getWidth() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   932
        return getSize().width;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   933
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   934
90ce3da70b43 Initial load
duke
parents:
diff changeset
   935
    public int getHeight() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   936
        return getSize().height;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   937
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   938
115
e270c597a3ad 6645885: small refactoring for XContentWindow
son
parents: 2
diff changeset
   939
    final public WindowDimensions getDimensions() {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   940
        return dimensions;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   941
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   942
90ce3da70b43 Initial load
duke
parents:
diff changeset
   943
    public Point getLocationOnScreen() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   944
        XToolkit.awtLock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   945
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   946
            if (configure_seen) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   947
                return toGlobal(0,0);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   948
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   949
                Point location = target.getLocation();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   950
                if (insLog.isLoggable(Level.FINE))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   951
                    insLog.log(Level.FINE, "getLocationOnScreen {0} not reparented: {1} ",
90ce3da70b43 Initial load
duke
parents:
diff changeset
   952
                               new Object[] {this, location});
90ce3da70b43 Initial load
duke
parents:
diff changeset
   953
                return location;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   954
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   955
        } finally {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   956
            XToolkit.awtUnlock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   957
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   958
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   959
90ce3da70b43 Initial load
duke
parents:
diff changeset
   960
90ce3da70b43 Initial load
duke
parents:
diff changeset
   961
/***************************************************************************************
90ce3da70b43 Initial load
duke
parents:
diff changeset
   962
 *              END            OF             I N S E T S   C O D E
90ce3da70b43 Initial load
duke
parents:
diff changeset
   963
 **************************************************************************************/
90ce3da70b43 Initial load
duke
parents:
diff changeset
   964
90ce3da70b43 Initial load
duke
parents:
diff changeset
   965
    protected boolean isEventDisabled(XEvent e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   966
        switch (e.get_type()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   967
            // Do not generate MOVED/RESIZED events since we generate them by ourselves
439
3488710b02f8 6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents: 420
diff changeset
   968
          case XConstants.ConfigureNotify:
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   969
              return true;
439
3488710b02f8 6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents: 420
diff changeset
   970
          case XConstants.EnterNotify:
3488710b02f8 6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents: 420
diff changeset
   971
          case XConstants.LeaveNotify:
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   972
              // Disable crossing event on outer borders of Frame so
90ce3da70b43 Initial load
duke
parents:
diff changeset
   973
              // we receive only one set of cross notifications(first set is from content window)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   974
              return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   975
          default:
90ce3da70b43 Initial load
duke
parents:
diff changeset
   976
              return super.isEventDisabled(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   977
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   978
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   979
90ce3da70b43 Initial load
duke
parents:
diff changeset
   980
    int getDecorations() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   981
        return winAttr.decorations;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   982
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   983
90ce3da70b43 Initial load
duke
parents:
diff changeset
   984
    int getFunctions() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   985
        return winAttr.functions;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   986
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   987
90ce3da70b43 Initial load
duke
parents:
diff changeset
   988
    public void setVisible(boolean vis) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   989
        log.log(Level.FINER, "Setting {0} to visible {1}", new Object[] {this, Boolean.valueOf(vis)});
90ce3da70b43 Initial load
duke
parents:
diff changeset
   990
        if (vis && !isVisible()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   991
            XWM.setShellDecor(this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   992
            super.setVisible(vis);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   993
            if (winAttr.isResizable) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   994
                //Fix for 4320050: Minimum size for java.awt.Frame is not being enforced.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   995
                //We need to update frame's minimum size, not to reset it
439
3488710b02f8 6623459: Get rid of XConstant, XProtocolConstants and XUtilConstants antipattern
dav
parents: 420
diff changeset
   996
                XWM.removeSizeHints(this, XUtilConstants.PMaxSize);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   997
                updateMinimumSize();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   998
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   999
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1000
            super.setVisible(vis);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1001
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1002
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1003
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1004
    protected void suppressWmTakeFocus(boolean doSuppress) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1005
        XAtomList protocols = getWMProtocols();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1006
        if (doSuppress) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1007
            protocols.remove(wm_take_focus);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1008
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1009
            protocols.add(wm_take_focus);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1010
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1011
        wm_protocols.setAtomListProperty(this, protocols);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1012
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1013
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1014
    public void dispose() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1015
        if (content != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1016
            content.destroy();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1017
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1018
        focusProxy.destroy();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1019
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1020
        if (iconWindow != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1021
            iconWindow.destroy();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1022
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1023
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1024
        super.dispose();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1025
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1026
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1027
    public void handleClientMessage(XEvent xev) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1028
        super.handleClientMessage(xev);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1029
        XClientMessageEvent cl = xev.get_xclient();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1030
        if ((wm_protocols != null) && (cl.get_message_type() == wm_protocols.getAtom())) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1031
            if (cl.get_data(0) == wm_delete_window.getAtom()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1032
                handleQuit();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1033
            } else if (cl.get_data(0) == wm_take_focus.getAtom()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1034
                handleWmTakeFocus(cl);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1035
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1036
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1037
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1038
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1039
    private void handleWmTakeFocus(XClientMessageEvent cl) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1040
        focusLog.log(Level.FINE, "WM_TAKE_FOCUS on {0}", new Object[]{this});
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1041
        requestWindowFocus(cl.get_data(1), true);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1042
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1043
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1044
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1045
     * Requests focus to this decorated top-level by requesting X input focus
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1046
     * to the shell window.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1047
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1048
    protected void requestXFocus(long time, boolean timeProvided) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1049
        // We have proxied focus mechanism - instead of shell the focus is held
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1050
        // by "proxy" - invisible mapped window. When we want to set X input focus to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1051
        // toplevel set it on proxy instead.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1052
        if (focusProxy == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1053
            if (focusLog.isLoggable(Level.FINE)) focusLog.warning("Focus proxy is null for " + this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1054
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1055
            if (focusLog.isLoggable(Level.FINE)) focusLog.fine("Requesting focus to proxy: " + focusProxy);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1056
            if (timeProvided) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1057
                focusProxy.xRequestFocus(time);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1058
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1059
                focusProxy.xRequestFocus();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1060
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1061
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1062
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1063
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1064
    XFocusProxyWindow getFocusProxy() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1065
        return focusProxy;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1066
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1067
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1068
    public void handleQuit() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1069
        postEvent(new WindowEvent((Window)target, WindowEvent.WINDOW_CLOSING));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1070
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1071
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1072
    final void dumpMe() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1073
        System.err.println(">>> Peer: " + x + ", " + y + ", " + width + ", " + height);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1074
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1075
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1076
    final void dumpTarget() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1077
        int getWidth = ComponentAccessor.getWidth((Component)target);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1078
        int getHeight = ComponentAccessor.getHeight((Component)target);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1079
        int getTargetX = ComponentAccessor.getX((Component)target);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1080
        int getTargetY = ComponentAccessor.getY((Component)target);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1081
        System.err.println(">>> Target: " + getTargetX + ", " + getTargetY + ", " + getWidth + ", " + getHeight);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1082
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1083
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1084
    final void dumpShell() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1085
        dumpWindow("Shell", getShell());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1086
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1087
    final void dumpContent() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1088
        dumpWindow("Content", getContentWindow());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1089
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1090
    final void dumpParent() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1091
        long parent = XlibUtil.getParentWindow(getShell());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1092
        if (parent != 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1093
        {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1094
            dumpWindow("Parent", parent);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1095
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1096
        else
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1097
        {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1098
            System.err.println(">>> NO PARENT");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1099
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1100
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1101
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1102
    final void dumpWindow(String id, long window) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1103
        XWindowAttributes pattr = new XWindowAttributes();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1104
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1105
            XToolkit.awtLock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1106
            try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1107
                int status =
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1108
                    XlibWrapper.XGetWindowAttributes(XToolkit.getDisplay(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1109
                                                     window, pattr.pData);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1110
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1111
            finally {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1112
                XToolkit.awtUnlock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1113
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1114
            System.err.println(">>>> " + id + ": " + pattr.get_x()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1115
                               + ", " + pattr.get_y() + ", " + pattr.get_width()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1116
                               + ", " + pattr.get_height());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1117
        } finally {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1118
            pattr.dispose();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1119
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1120
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1121
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1122
    final void dumpAll() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1123
        dumpTarget();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1124
        dumpMe();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1125
        dumpParent();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1126
        dumpShell();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1127
        dumpContent();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1128
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1129
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1130
    boolean isMaximized() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1131
        return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1132
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1133
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1134
    boolean isOverrideRedirect() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1135
        return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1136
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1137
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1138
    public boolean requestWindowFocus(long time, boolean timeProvided) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1139
        focusLog.fine("Request for decorated window focus");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1140
        // If this is Frame or Dialog we can't assure focus request success - but we still can try
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1141
        // If this is Window and its owner Frame is active we can be sure request succedded.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1142
        Window focusedWindow = XKeyboardFocusManagerPeer.getCurrentNativeFocusedWindow();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1143
        Window activeWindow = XWindowPeer.getDecoratedOwner(focusedWindow);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1144
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1145
        focusLog.log(Level.FINER, "Current window is: active={0}, focused={1}",
442
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1146
                     new Object[]{ Boolean.valueOf(target == activeWindow),
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1147
                                   Boolean.valueOf(target == focusedWindow)});
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1148
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1149
        XWindowPeer toFocus = this;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1150
        while (toFocus.nextTransientFor != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1151
            toFocus = toFocus.nextTransientFor;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1152
        }
442
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1153
        if (toFocus == null || !toFocus.focusAllowedFor()) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1154
            // This might change when WM will have property to determine focus policy.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1155
            // Right now, because policy is unknown we can't be sure we succedded
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1156
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1157
        }
442
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1158
        if (this == toFocus) {
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1159
            if (isWMStateNetHidden()) {
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1160
                focusLog.fine("The window is unmapped, so rejecting the request");
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1161
                return false;
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1162
            }
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1163
            if (target == activeWindow && target != focusedWindow) {
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1164
                // Happens when an owned window is currently focused
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1165
                focusLog.fine("Focus is on child window - transfering it back to the owner");
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1166
                handleWindowFocusInSync(-1);
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1167
                return true;
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1168
            }
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1169
            Window realNativeFocusedWindow = XWindowPeer.getNativeFocusedWindow();
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1170
            focusLog.finest("Real native focused window: " + realNativeFocusedWindow +
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1171
                            "\nKFM's focused window: " + focusedWindow);
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1172
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1173
            // See 6522725, 6613426.
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1174
            if (target == realNativeFocusedWindow) {
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1175
                focusLog.fine("The window is already natively focused.");
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1176
                return true;
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1177
            }
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1178
        }
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1179
        focusLog.fine("Requesting focus to " + (this == toFocus ? "this window" : toFocus));
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1180
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1181
        if (timeProvided) {
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1182
            toFocus.requestXFocus(time);
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1183
        } else {
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1184
            toFocus.requestXFocus();
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1185
        }
687798d7d7b6 6522725: Component in a minimized Frame has focus and receives key events
ant
parents: 439
diff changeset
  1186
        return (this == toFocus);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1187
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1188
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1189
    XWindowPeer actualFocusedWindow = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1190
    void setActualFocusedWindow(XWindowPeer actualFocusedWindow) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1191
        synchronized(getStateLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1192
            this.actualFocusedWindow = actualFocusedWindow;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1193
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1194
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1195
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1196
    boolean requestWindowFocus(XWindowPeer actualFocusedWindow,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1197
                               long time, boolean timeProvided)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1198
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1199
        setActualFocusedWindow(actualFocusedWindow);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1200
        return requestWindowFocus(time, timeProvided);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1201
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1202
    public void handleWindowFocusIn(long serial) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1203
        if (null == actualFocusedWindow) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1204
            super.handleWindowFocusIn(serial);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1205
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1206
            /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1207
             * Fix for 6314575.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1208
             * If this is a result of clicking on one of the Frame's component
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1209
             * then 'actualFocusedWindow' shouldn't be focused. A decision of focusing
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1210
             * it or not should be made after the appropriate Java mouse event (if any)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1211
             * is handled by the component where 'actualFocusedWindow' value may be reset.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1212
             *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1213
             * The fix is based on the empiric fact consisting in that the component
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1214
             * receives native mouse event nearly at the same time the Frame receives
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1215
             * WM_TAKE_FOCUS (when FocusIn is generated via XSetInputFocus call) but
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1216
             * definetely before the Frame gets FocusIn event (when this method is called).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1217
             */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1218
            postEvent(new InvocationEvent(target, new Runnable() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1219
                public void run() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1220
                    XWindowPeer fw = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1221
                    synchronized (getStateLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1222
                        fw = actualFocusedWindow;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1223
                        actualFocusedWindow = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1224
                        if (null == fw || !fw.isVisible() || !fw.isFocusableWindow()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1225
                            fw = XDecoratedPeer.this;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1226
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1227
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1228
                    fw.handleWindowFocusIn_Dispatch();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1229
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1230
            }));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1231
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1232
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1233
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1234
    public void handleWindowFocusOut(Window oppositeWindow, long serial) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1235
        Window actualFocusedWindow = XKeyboardFocusManagerPeer.getCurrentNativeFocusedWindow();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1236
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1237
        // If the actual focused window is not this decorated window then retain it.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1238
        if (actualFocusedWindow != null && actualFocusedWindow != target) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1239
            Window owner = XWindowPeer.getDecoratedOwner(actualFocusedWindow);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1240
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1241
            if (owner != null && owner == target) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1242
                setActualFocusedWindow((XWindowPeer) ComponentAccessor.getPeer(actualFocusedWindow));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1243
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1244
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1245
        super.handleWindowFocusOut(oppositeWindow, serial);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1246
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1247
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1248
    private Point queryXLocation()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1249
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1250
        return XlibUtil.translateCoordinates(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1251
            getContentWindow(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1252
            XlibWrapper.RootWindow(XToolkit.getDisplay(), getScreenNumber()),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1253
            new Point(0, 0));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1254
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1255
}