jdk/src/share/classes/java/awt/Container.java
author yan
Tue, 06 Oct 2009 23:40:27 -0700
changeset 3972 8942e64cf57d
parent 3938 ef327bd847c0
parent 3971 067e6580a577
child 4259 b41995ac0c17
permissions -rw-r--r--
Merge
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
     1
/*
2451
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
     2
 * Copyright 1995-2009 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 java.awt;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    26
90ce3da70b43 Initial load
duke
parents:
diff changeset
    27
import java.awt.dnd.DropTarget;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    28
90ce3da70b43 Initial load
duke
parents:
diff changeset
    29
import java.awt.event.*;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    30
90ce3da70b43 Initial load
duke
parents:
diff changeset
    31
import java.awt.peer.ContainerPeer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    32
import java.awt.peer.ComponentPeer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    33
import java.awt.peer.LightweightPeer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    34
90ce3da70b43 Initial load
duke
parents:
diff changeset
    35
import java.beans.PropertyChangeListener;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    36
90ce3da70b43 Initial load
duke
parents:
diff changeset
    37
import java.io.IOException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    38
import java.io.ObjectInputStream;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    39
import java.io.ObjectOutputStream;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    40
import java.io.ObjectStreamField;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    41
import java.io.PrintStream;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    42
import java.io.PrintWriter;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    43
90ce3da70b43 Initial load
duke
parents:
diff changeset
    44
import java.util.Arrays;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    45
import java.util.EventListener;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    46
import java.util.HashSet;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    47
import java.util.Set;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    48
90ce3da70b43 Initial load
duke
parents:
diff changeset
    49
import javax.accessibility.*;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    50
3938
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
    51
import sun.util.logging.PlatformLogger;
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
    52
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    53
import sun.awt.AppContext;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    54
import sun.awt.CausedFocusEvent;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    55
import sun.awt.PeerEvent;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    56
import sun.awt.SunToolkit;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    57
90ce3da70b43 Initial load
duke
parents:
diff changeset
    58
import sun.awt.dnd.SunDropTargetEvent;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    59
90ce3da70b43 Initial load
duke
parents:
diff changeset
    60
import sun.java2d.pipe.Region;
90ce3da70b43 Initial load
duke
parents:
diff changeset
    61
90ce3da70b43 Initial load
duke
parents:
diff changeset
    62
/**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    63
 * A generic Abstract Window Toolkit(AWT) container object is a component
90ce3da70b43 Initial load
duke
parents:
diff changeset
    64
 * that can contain other AWT components.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    65
 * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    66
 * Components added to a container are tracked in a list.  The order
90ce3da70b43 Initial load
duke
parents:
diff changeset
    67
 * of the list will define the components' front-to-back stacking order
90ce3da70b43 Initial load
duke
parents:
diff changeset
    68
 * within the container.  If no index is specified when adding a
90ce3da70b43 Initial load
duke
parents:
diff changeset
    69
 * component to a container, it will be added to the end of the list
90ce3da70b43 Initial load
duke
parents:
diff changeset
    70
 * (and hence to the bottom of the stacking order).
90ce3da70b43 Initial load
duke
parents:
diff changeset
    71
 * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    72
 * <b>Note</b>: For details on the focus subsystem, see
90ce3da70b43 Initial load
duke
parents:
diff changeset
    73
 * <a href="http://java.sun.com/docs/books/tutorial/uiswing/misc/focus.html">
90ce3da70b43 Initial load
duke
parents:
diff changeset
    74
 * How to Use the Focus Subsystem</a>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
    75
 * a section in <em>The Java Tutorial</em>, and the
90ce3da70b43 Initial load
duke
parents:
diff changeset
    76
 * <a href="../../java/awt/doc-files/FocusSpec.html">Focus Specification</a>
90ce3da70b43 Initial load
duke
parents:
diff changeset
    77
 * for more information.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    78
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
    79
 * @author      Arthur van Hoff
90ce3da70b43 Initial load
duke
parents:
diff changeset
    80
 * @author      Sami Shaio
90ce3da70b43 Initial load
duke
parents:
diff changeset
    81
 * @see       #add(java.awt.Component, int)
90ce3da70b43 Initial load
duke
parents:
diff changeset
    82
 * @see       #getComponent(int)
90ce3da70b43 Initial load
duke
parents:
diff changeset
    83
 * @see       LayoutManager
90ce3da70b43 Initial load
duke
parents:
diff changeset
    84
 * @since     JDK1.0
90ce3da70b43 Initial load
duke
parents:
diff changeset
    85
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
    86
public class Container extends Component {
90ce3da70b43 Initial load
duke
parents:
diff changeset
    87
3938
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
    88
    private static final PlatformLogger log = PlatformLogger.getLogger("java.awt.Container");
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
    89
    private static final PlatformLogger eventLog = PlatformLogger.getLogger("java.awt.event.Container");
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    90
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
    91
    private static final Component[] EMPTY_ARRAY = new Component[0];
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    92
90ce3da70b43 Initial load
duke
parents:
diff changeset
    93
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
    94
     * The components in this container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
    95
     * @see #add
90ce3da70b43 Initial load
duke
parents:
diff changeset
    96
     * @see #getComponents
90ce3da70b43 Initial load
duke
parents:
diff changeset
    97
     */
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
    98
    private java.util.List<Component> component = new java.util.ArrayList<Component>();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
    99
90ce3da70b43 Initial load
duke
parents:
diff changeset
   100
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   101
     * Layout manager for this container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   102
     * @see #doLayout
90ce3da70b43 Initial load
duke
parents:
diff changeset
   103
     * @see #setLayout
90ce3da70b43 Initial load
duke
parents:
diff changeset
   104
     * @see #getLayout
90ce3da70b43 Initial load
duke
parents:
diff changeset
   105
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   106
    LayoutManager layoutMgr;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   107
90ce3da70b43 Initial load
duke
parents:
diff changeset
   108
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   109
     * Event router for lightweight components.  If this container
90ce3da70b43 Initial load
duke
parents:
diff changeset
   110
     * is native, this dispatcher takes care of forwarding and
90ce3da70b43 Initial load
duke
parents:
diff changeset
   111
     * retargeting the events to lightweight components contained
90ce3da70b43 Initial load
duke
parents:
diff changeset
   112
     * (if any).
90ce3da70b43 Initial load
duke
parents:
diff changeset
   113
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   114
    private LightweightDispatcher dispatcher;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   115
90ce3da70b43 Initial load
duke
parents:
diff changeset
   116
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   117
     * The focus traversal policy that will manage keyboard traversal of this
90ce3da70b43 Initial load
duke
parents:
diff changeset
   118
     * Container's children, if this Container is a focus cycle root. If the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   119
     * value is null, this Container inherits its policy from its focus-cycle-
90ce3da70b43 Initial load
duke
parents:
diff changeset
   120
     * root ancestor. If all such ancestors of this Container have null
90ce3da70b43 Initial load
duke
parents:
diff changeset
   121
     * policies, then the current KeyboardFocusManager's default policy is
90ce3da70b43 Initial load
duke
parents:
diff changeset
   122
     * used. If the value is non-null, this policy will be inherited by all
90ce3da70b43 Initial load
duke
parents:
diff changeset
   123
     * focus-cycle-root children that have no keyboard-traversal policy of
90ce3da70b43 Initial load
duke
parents:
diff changeset
   124
     * their own (as will, recursively, their focus-cycle-root children).
90ce3da70b43 Initial load
duke
parents:
diff changeset
   125
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   126
     * If this Container is not a focus cycle root, the value will be
90ce3da70b43 Initial load
duke
parents:
diff changeset
   127
     * remembered, but will not be used or inherited by this or any other
90ce3da70b43 Initial load
duke
parents:
diff changeset
   128
     * Containers until this Container is made a focus cycle root.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   129
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   130
     * @see #setFocusTraversalPolicy
90ce3da70b43 Initial load
duke
parents:
diff changeset
   131
     * @see #getFocusTraversalPolicy
90ce3da70b43 Initial load
duke
parents:
diff changeset
   132
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   133
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   134
    private transient FocusTraversalPolicy focusTraversalPolicy;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   135
90ce3da70b43 Initial load
duke
parents:
diff changeset
   136
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   137
     * Indicates whether this Component is the root of a focus traversal cycle.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   138
     * Once focus enters a traversal cycle, typically it cannot leave it via
90ce3da70b43 Initial load
duke
parents:
diff changeset
   139
     * focus traversal unless one of the up- or down-cycle keys is pressed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   140
     * Normal traversal is limited to this Container, and all of this
90ce3da70b43 Initial load
duke
parents:
diff changeset
   141
     * Container's descendants that are not descendants of inferior focus cycle
90ce3da70b43 Initial load
duke
parents:
diff changeset
   142
     * roots.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   143
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   144
     * @see #setFocusCycleRoot
90ce3da70b43 Initial load
duke
parents:
diff changeset
   145
     * @see #isFocusCycleRoot
90ce3da70b43 Initial load
duke
parents:
diff changeset
   146
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
   147
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   148
    private boolean focusCycleRoot = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   149
90ce3da70b43 Initial load
duke
parents:
diff changeset
   150
90ce3da70b43 Initial load
duke
parents:
diff changeset
   151
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   152
     * Stores the value of focusTraversalPolicyProvider property.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   153
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
   154
     * @see #setFocusTraversalPolicyProvider
90ce3da70b43 Initial load
duke
parents:
diff changeset
   155
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   156
    private boolean focusTraversalPolicyProvider;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   157
90ce3da70b43 Initial load
duke
parents:
diff changeset
   158
    // keeps track of the threads that are printing this component
90ce3da70b43 Initial load
duke
parents:
diff changeset
   159
    private transient Set printingThreads;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   160
    // True if there is at least one thread that's printing this component
90ce3da70b43 Initial load
duke
parents:
diff changeset
   161
    private transient boolean printing = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   162
90ce3da70b43 Initial load
duke
parents:
diff changeset
   163
    transient ContainerListener containerListener;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   164
90ce3da70b43 Initial load
duke
parents:
diff changeset
   165
    /* HierarchyListener and HierarchyBoundsListener support */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   166
    transient int listeningChildren;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   167
    transient int listeningBoundsChildren;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   168
    transient int descendantsCount;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   169
2451
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   170
    /* Non-opaque window support -- see Window.setLayersOpaque */
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   171
    transient Color preserveBackgroundColor = null;
597df8e1d786 6633275: Need to support shaped/translucent windows
art
parents: 1978
diff changeset
   172
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   173
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   174
     * JDK 1.1 serialVersionUID
90ce3da70b43 Initial load
duke
parents:
diff changeset
   175
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   176
    private static final long serialVersionUID = 4613797578919906343L;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   177
90ce3da70b43 Initial load
duke
parents:
diff changeset
   178
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   179
     * A constant which toggles one of the controllable behaviors
90ce3da70b43 Initial load
duke
parents:
diff changeset
   180
     * of <code>getMouseEventTarget</code>. It is used to specify whether
90ce3da70b43 Initial load
duke
parents:
diff changeset
   181
     * the method can return the Container on which it is originally called
90ce3da70b43 Initial load
duke
parents:
diff changeset
   182
     * in case if none of its children are the current mouse event targets.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   183
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   184
     * @see #getMouseEventTarget(int, int, boolean, boolean, boolean)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   185
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   186
    static final boolean INCLUDE_SELF = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   187
90ce3da70b43 Initial load
duke
parents:
diff changeset
   188
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   189
     * A constant which toggles one of the controllable behaviors
90ce3da70b43 Initial load
duke
parents:
diff changeset
   190
     * of <code>getMouseEventTarget</code>. It is used to specify whether
90ce3da70b43 Initial load
duke
parents:
diff changeset
   191
     * the method should search only lightweight components.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   192
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   193
     * @see #getMouseEventTarget(int, int, boolean, boolean, boolean)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   194
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   195
    static final boolean SEARCH_HEAVYWEIGHTS = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   196
90ce3da70b43 Initial load
duke
parents:
diff changeset
   197
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
   198
     * Number of HW or LW components in this container (including
90ce3da70b43 Initial load
duke
parents:
diff changeset
   199
     * all descendant containers).
90ce3da70b43 Initial load
duke
parents:
diff changeset
   200
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   201
    private transient int numOfHWComponents = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   202
    private transient int numOfLWComponents = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   203
3938
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
   204
    private static final PlatformLogger mixingLog = PlatformLogger.getLogger("java.awt.mixing.Container");
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   205
90ce3da70b43 Initial load
duke
parents:
diff changeset
   206
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   207
     * @serialField ncomponents                     int
90ce3da70b43 Initial load
duke
parents:
diff changeset
   208
     *       The number of components in this container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   209
     *       This value can be null.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   210
     * @serialField component                       Component[]
90ce3da70b43 Initial load
duke
parents:
diff changeset
   211
     *       The components in this container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   212
     * @serialField layoutMgr                       LayoutManager
90ce3da70b43 Initial load
duke
parents:
diff changeset
   213
     *       Layout manager for this container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   214
     * @serialField dispatcher                      LightweightDispatcher
90ce3da70b43 Initial load
duke
parents:
diff changeset
   215
     *       Event router for lightweight components.  If this container
90ce3da70b43 Initial load
duke
parents:
diff changeset
   216
     *       is native, this dispatcher takes care of forwarding and
90ce3da70b43 Initial load
duke
parents:
diff changeset
   217
     *       retargeting the events to lightweight components contained
90ce3da70b43 Initial load
duke
parents:
diff changeset
   218
     *       (if any).
90ce3da70b43 Initial load
duke
parents:
diff changeset
   219
     * @serialField maxSize                         Dimension
90ce3da70b43 Initial load
duke
parents:
diff changeset
   220
     *       Maximum size of this Container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   221
     * @serialField focusCycleRoot                  boolean
90ce3da70b43 Initial load
duke
parents:
diff changeset
   222
     *       Indicates whether this Component is the root of a focus traversal cycle.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   223
     *       Once focus enters a traversal cycle, typically it cannot leave it via
90ce3da70b43 Initial load
duke
parents:
diff changeset
   224
     *       focus traversal unless one of the up- or down-cycle keys is pressed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   225
     *       Normal traversal is limited to this Container, and all of this
90ce3da70b43 Initial load
duke
parents:
diff changeset
   226
     *       Container's descendants that are not descendants of inferior focus cycle
90ce3da70b43 Initial load
duke
parents:
diff changeset
   227
     *       roots.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   228
     * @serialField containerSerializedDataVersion  int
90ce3da70b43 Initial load
duke
parents:
diff changeset
   229
     *       Container Serial Data Version.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   230
     * @serialField focusTraversalPolicyProvider    boolean
90ce3da70b43 Initial load
duke
parents:
diff changeset
   231
     *       Stores the value of focusTraversalPolicyProvider property.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   232
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   233
    private static final ObjectStreamField[] serialPersistentFields = {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   234
        new ObjectStreamField("ncomponents", Integer.TYPE),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   235
        new ObjectStreamField("component", Component[].class),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   236
        new ObjectStreamField("layoutMgr", LayoutManager.class),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   237
        new ObjectStreamField("dispatcher", LightweightDispatcher.class),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   238
        new ObjectStreamField("maxSize", Dimension.class),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   239
        new ObjectStreamField("focusCycleRoot", Boolean.TYPE),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   240
        new ObjectStreamField("containerSerializedDataVersion", Integer.TYPE),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   241
        new ObjectStreamField("focusTraversalPolicyProvider", Boolean.TYPE),
90ce3da70b43 Initial load
duke
parents:
diff changeset
   242
    };
90ce3da70b43 Initial load
duke
parents:
diff changeset
   243
90ce3da70b43 Initial load
duke
parents:
diff changeset
   244
    static {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   245
        /* ensure that the necessary native libraries are loaded */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   246
        Toolkit.loadLibraries();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   247
        if (!GraphicsEnvironment.isHeadless()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   248
            initIDs();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   249
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   250
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   251
90ce3da70b43 Initial load
duke
parents:
diff changeset
   252
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   253
     * Initialize JNI field and method IDs for fields that may be
90ce3da70b43 Initial load
duke
parents:
diff changeset
   254
       called from C.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   255
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   256
    private static native void initIDs();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   257
90ce3da70b43 Initial load
duke
parents:
diff changeset
   258
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   259
     * Constructs a new Container. Containers can be extended directly,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   260
     * but are lightweight in this case and must be contained by a parent
90ce3da70b43 Initial load
duke
parents:
diff changeset
   261
     * somewhere higher up in the component tree that is native.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   262
     * (such as Frame for example).
90ce3da70b43 Initial load
duke
parents:
diff changeset
   263
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   264
    public Container() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   265
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   266
90ce3da70b43 Initial load
duke
parents:
diff changeset
   267
    void initializeFocusTraversalKeys() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   268
        focusTraversalKeys = new Set[4];
90ce3da70b43 Initial load
duke
parents:
diff changeset
   269
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   270
90ce3da70b43 Initial load
duke
parents:
diff changeset
   271
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   272
     * Gets the number of components in this panel.
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   273
     * <p>
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   274
     * Note: This method should be called under AWT tree lock.
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   275
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   276
     * @return    the number of components in this panel.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   277
     * @see       #getComponent
90ce3da70b43 Initial load
duke
parents:
diff changeset
   278
     * @since     JDK1.1
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   279
     * @see Component#getTreeLock()
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   280
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   281
    public int getComponentCount() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   282
        return countComponents();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   283
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   284
90ce3da70b43 Initial load
duke
parents:
diff changeset
   285
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   286
     * @deprecated As of JDK version 1.1,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   287
     * replaced by getComponentCount().
90ce3da70b43 Initial load
duke
parents:
diff changeset
   288
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   289
    @Deprecated
90ce3da70b43 Initial load
duke
parents:
diff changeset
   290
    public int countComponents() {
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   291
        // This method is not synchronized under AWT tree lock.
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   292
        // Instead, the calling code is responsible for the
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   293
        // synchronization. See 6784816 for details.
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   294
        return component.size();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   295
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   296
90ce3da70b43 Initial load
duke
parents:
diff changeset
   297
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   298
     * Gets the nth component in this container.
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   299
     * <p>
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   300
     * Note: This method should be called under AWT tree lock.
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   301
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   302
     * @param      n   the index of the component to get.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   303
     * @return     the n<sup>th</sup> component in this container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   304
     * @exception  ArrayIndexOutOfBoundsException
90ce3da70b43 Initial load
duke
parents:
diff changeset
   305
     *                 if the n<sup>th</sup> value does not exist.
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   306
     * @see Component#getTreeLock()
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   307
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   308
    public Component getComponent(int n) {
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   309
        // This method is not synchronized under AWT tree lock.
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   310
        // Instead, the calling code is responsible for the
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   311
        // synchronization. See 6784816 for details.
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   312
        try {
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   313
            return component.get(n);
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   314
        } catch (IndexOutOfBoundsException z) {
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   315
            throw new ArrayIndexOutOfBoundsException("No such child: " + n);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   316
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   317
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   318
90ce3da70b43 Initial load
duke
parents:
diff changeset
   319
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   320
     * Gets all the components in this container.
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   321
     * <p>
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   322
     * Note: This method should be called under AWT tree lock.
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   323
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   324
     * @return    an array of all the components in this container.
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   325
     * @see Component#getTreeLock()
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   326
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   327
    public Component[] getComponents() {
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   328
        // This method is not synchronized under AWT tree lock.
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   329
        // Instead, the calling code is responsible for the
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   330
        // synchronization. See 6784816 for details.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   331
        return getComponents_NoClientCode();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   332
    }
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   333
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   334
    // NOTE: This method may be called by privileged threads.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   335
    //       This functionality is implemented in a package-private method
90ce3da70b43 Initial load
duke
parents:
diff changeset
   336
    //       to insure that it cannot be overridden by client subclasses.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   337
    //       DO NOT INVOKE CLIENT CODE ON THIS THREAD!
90ce3da70b43 Initial load
duke
parents:
diff changeset
   338
    final Component[] getComponents_NoClientCode() {
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   339
        return component.toArray(EMPTY_ARRAY);
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   340
    }
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   341
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   342
    /*
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   343
     * Wrapper for getComponents() method with a proper synchronization.
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   344
     */
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   345
    Component[] getComponentsSync() {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   346
        synchronized (getTreeLock()) {
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   347
            return getComponents();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   348
        }
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
   349
    }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   350
90ce3da70b43 Initial load
duke
parents:
diff changeset
   351
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   352
     * Determines the insets of this container, which indicate the size
90ce3da70b43 Initial load
duke
parents:
diff changeset
   353
     * of the container's border.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   354
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   355
     * A <code>Frame</code> object, for example, has a top inset that
90ce3da70b43 Initial load
duke
parents:
diff changeset
   356
     * corresponds to the height of the frame's title bar.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   357
     * @return    the insets of this container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   358
     * @see       Insets
90ce3da70b43 Initial load
duke
parents:
diff changeset
   359
     * @see       LayoutManager
90ce3da70b43 Initial load
duke
parents:
diff changeset
   360
     * @since     JDK1.1
90ce3da70b43 Initial load
duke
parents:
diff changeset
   361
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   362
    public Insets getInsets() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   363
        return insets();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   364
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   365
90ce3da70b43 Initial load
duke
parents:
diff changeset
   366
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   367
     * @deprecated As of JDK version 1.1,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   368
     * replaced by <code>getInsets()</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   369
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   370
    @Deprecated
90ce3da70b43 Initial load
duke
parents:
diff changeset
   371
    public Insets insets() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   372
        ComponentPeer peer = this.peer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   373
        if (peer instanceof ContainerPeer) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   374
            ContainerPeer cpeer = (ContainerPeer)peer;
1964
934568dfe859 6749920: Cleanup AWT peer interfaces
rkennke
parents: 1188
diff changeset
   375
            return (Insets)cpeer.getInsets().clone();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   376
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   377
        return new Insets(0, 0, 0, 0);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   378
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   379
90ce3da70b43 Initial load
duke
parents:
diff changeset
   380
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   381
     * Appends the specified component to the end of this container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   382
     * This is a convenience method for {@link #addImpl}.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   383
     * <p>
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   384
     * This method changes layout-related information, and therefore,
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   385
     * invalidates the component hierarchy. If the container has already been
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   386
     * displayed, the hierarchy must be validated thereafter in order to
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   387
     * display the added component.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   388
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   389
     * @param     comp   the component to be added
90ce3da70b43 Initial load
duke
parents:
diff changeset
   390
     * @exception NullPointerException if {@code comp} is {@code null}
90ce3da70b43 Initial load
duke
parents:
diff changeset
   391
     * @see #addImpl
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   392
     * @see #invalidate
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   393
     * @see #validate
90ce3da70b43 Initial load
duke
parents:
diff changeset
   394
     * @see javax.swing.JComponent#revalidate()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   395
     * @return    the component argument
90ce3da70b43 Initial load
duke
parents:
diff changeset
   396
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   397
    public Component add(Component comp) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   398
        addImpl(comp, null, -1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   399
        return comp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   400
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   401
90ce3da70b43 Initial load
duke
parents:
diff changeset
   402
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   403
     * Adds the specified component to this container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   404
     * This is a convenience method for {@link #addImpl}.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   405
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   406
     * This method is obsolete as of 1.1.  Please use the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   407
     * method <code>add(Component, Object)</code> instead.
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   408
     * <p>
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   409
     * This method changes layout-related information, and therefore,
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   410
     * invalidates the component hierarchy. If the container has already been
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   411
     * displayed, the hierarchy must be validated thereafter in order to
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   412
     * display the added component.
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   413
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   414
     * @exception NullPointerException if {@code comp} is {@code null}
90ce3da70b43 Initial load
duke
parents:
diff changeset
   415
     * @see #add(Component, Object)
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   416
     * @see #invalidate
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   417
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   418
    public Component add(String name, Component comp) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   419
        addImpl(comp, name, -1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   420
        return comp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   421
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   422
90ce3da70b43 Initial load
duke
parents:
diff changeset
   423
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   424
     * Adds the specified component to this container at the given
90ce3da70b43 Initial load
duke
parents:
diff changeset
   425
     * position.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   426
     * This is a convenience method for {@link #addImpl}.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   427
     * <p>
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   428
     * This method changes layout-related information, and therefore,
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   429
     * invalidates the component hierarchy. If the container has already been
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   430
     * displayed, the hierarchy must be validated thereafter in order to
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   431
     * display the added component.
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   432
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   433
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   434
     * @param     comp   the component to be added
90ce3da70b43 Initial load
duke
parents:
diff changeset
   435
     * @param     index    the position at which to insert the component,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   436
     *                   or <code>-1</code> to append the component to the end
90ce3da70b43 Initial load
duke
parents:
diff changeset
   437
     * @exception NullPointerException if {@code comp} is {@code null}
90ce3da70b43 Initial load
duke
parents:
diff changeset
   438
     * @exception IllegalArgumentException if {@code index} is invalid (see
90ce3da70b43 Initial load
duke
parents:
diff changeset
   439
     *            {@link #addImpl} for details)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   440
     * @return    the component <code>comp</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   441
     * @see #addImpl
90ce3da70b43 Initial load
duke
parents:
diff changeset
   442
     * @see #remove
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   443
     * @see #invalidate
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   444
     * @see #validate
90ce3da70b43 Initial load
duke
parents:
diff changeset
   445
     * @see javax.swing.JComponent#revalidate()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   446
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   447
    public Component add(Component comp, int index) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   448
        addImpl(comp, null, index);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   449
        return comp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   450
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   451
90ce3da70b43 Initial load
duke
parents:
diff changeset
   452
    /**
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   453
     * Checks that the component
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   454
     * isn't supposed to be added into itself.
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   455
     */
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   456
    private void checkAddToSelf(Component comp){
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   457
        if (comp instanceof Container) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   458
            for (Container cn = this; cn != null; cn=cn.parent) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   459
                if (cn == comp) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   460
                    throw new IllegalArgumentException("adding container's parent to itself");
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   461
                }
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   462
            }
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   463
        }
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   464
    }
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   465
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   466
    /**
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   467
     * Checks that the component is not a Window instance.
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   468
     */
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   469
    private void checkNotAWindow(Component comp){
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   470
        if (comp instanceof Window) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   471
            throw new IllegalArgumentException("adding a window to a container");
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   472
        }
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   473
    }
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   474
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   475
    /**
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   476
     * Checks that the component comp can be added to this container
90ce3da70b43 Initial load
duke
parents:
diff changeset
   477
     * Checks :  index in bounds of container's size,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   478
     * comp is not one of this container's parents,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   479
     * and comp is not a window.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   480
     * Comp and container must be on the same GraphicsDevice.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   481
     * if comp is container, all sub-components must be on
90ce3da70b43 Initial load
duke
parents:
diff changeset
   482
     * same GraphicsDevice.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   483
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   484
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
   485
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   486
    private void checkAdding(Component comp, int index) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   487
        checkTreeLock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   488
90ce3da70b43 Initial load
duke
parents:
diff changeset
   489
        GraphicsConfiguration thisGC = getGraphicsConfiguration();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   490
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   491
        if (index > component.size() || index < 0) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   492
            throw new IllegalArgumentException("illegal component position");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   493
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   494
        if (comp.parent == this) {
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   495
            if (index == component.size()) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   496
                throw new IllegalArgumentException("illegal component position " +
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   497
                                                   index + " should be less then " + component.size());
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   498
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   499
        }
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   500
        checkAddToSelf(comp);
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   501
        checkNotAWindow(comp);
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   502
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   503
        Window thisTopLevel = getContainingWindow();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   504
        Window compTopLevel = comp.getContainingWindow();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   505
        if (thisTopLevel != compTopLevel) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   506
            throw new IllegalArgumentException("component and container should be in the same top-level window");
90ce3da70b43 Initial load
duke
parents:
diff changeset
   507
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   508
        if (thisGC != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   509
            comp.checkGD(thisGC.getDevice().getIDstring());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   510
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   511
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   512
90ce3da70b43 Initial load
duke
parents:
diff changeset
   513
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   514
     * Removes component comp from this container without making unneccessary changes
90ce3da70b43 Initial load
duke
parents:
diff changeset
   515
     * and generating unneccessary events. This function intended to perform optimized
90ce3da70b43 Initial load
duke
parents:
diff changeset
   516
     * remove, for example, if newParent and current parent are the same it just changes
90ce3da70b43 Initial load
duke
parents:
diff changeset
   517
     * index without calling removeNotify.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   518
     * Note: Should be called while holding treeLock
90ce3da70b43 Initial load
duke
parents:
diff changeset
   519
     * Returns whether removeNotify was invoked
90ce3da70b43 Initial load
duke
parents:
diff changeset
   520
     * @since: 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
   521
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   522
    private boolean removeDelicately(Component comp, Container newParent, int newIndex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   523
        checkTreeLock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   524
90ce3da70b43 Initial load
duke
parents:
diff changeset
   525
        int index = getComponentZOrder(comp);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   526
        boolean needRemoveNotify = isRemoveNotifyNeeded(comp, this, newParent);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   527
        if (needRemoveNotify) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   528
            comp.removeNotify();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   529
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   530
        if (newParent != this) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   531
            if (layoutMgr != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   532
                layoutMgr.removeLayoutComponent(comp);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   533
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   534
            adjustListeningChildren(AWTEvent.HIERARCHY_EVENT_MASK,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   535
                                    -comp.numListening(AWTEvent.HIERARCHY_EVENT_MASK));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   536
            adjustListeningChildren(AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   537
                                    -comp.numListening(AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   538
            adjustDescendants(-(comp.countHierarchyMembers()));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   539
90ce3da70b43 Initial load
duke
parents:
diff changeset
   540
            comp.parent = null;
2461
5a213483d221 6811674: Container.setComponentZOrder throws NPE
anthony
parents: 2459
diff changeset
   541
            if (needRemoveNotify) {
5a213483d221 6811674: Container.setComponentZOrder throws NPE
anthony
parents: 2459
diff changeset
   542
                comp.setGraphicsConfiguration(null);
5a213483d221 6811674: Container.setComponentZOrder throws NPE
anthony
parents: 2459
diff changeset
   543
            }
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   544
            component.remove(index);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   545
1183
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
   546
            invalidateIfValid();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   547
        } else {
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   548
            // We should remove component and then
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   549
            // add it by the newIndex without newIndex decrement if even we shift components to the left
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   550
            // after remove. Consult the rules below:
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   551
            // 2->4: 012345 -> 013425, 2->5: 012345 -> 013452
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   552
            // 4->2: 012345 -> 014235
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   553
            component.remove(index);
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   554
            component.add(newIndex, comp);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   555
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   556
        if (comp.parent == null) { // was actually removed
90ce3da70b43 Initial load
duke
parents:
diff changeset
   557
            if (containerListener != null ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
   558
                (eventMask & AWTEvent.CONTAINER_EVENT_MASK) != 0 ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
   559
                Toolkit.enabledOnToolkit(AWTEvent.CONTAINER_EVENT_MASK)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   560
                ContainerEvent e = new ContainerEvent(this,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   561
                                                      ContainerEvent.COMPONENT_REMOVED,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   562
                                                      comp);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   563
                dispatchEvent(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   564
90ce3da70b43 Initial load
duke
parents:
diff changeset
   565
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   566
            comp.createHierarchyEvents(HierarchyEvent.HIERARCHY_CHANGED, comp,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   567
                                       this, HierarchyEvent.PARENT_CHANGED,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   568
                                       Toolkit.enabledOnToolkit(AWTEvent.HIERARCHY_EVENT_MASK));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   569
            if (peer != null && layoutMgr == null && isVisible()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   570
                updateCursorImmediately();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   571
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   572
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   573
        return needRemoveNotify;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   574
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   575
90ce3da70b43 Initial load
duke
parents:
diff changeset
   576
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   577
     * Checks whether this container can contain component which is focus owner.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   578
     * Verifies that container is enable and showing, and if it is focus cycle root
90ce3da70b43 Initial load
duke
parents:
diff changeset
   579
     * its FTP allows component to be focus owner
90ce3da70b43 Initial load
duke
parents:
diff changeset
   580
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
   581
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   582
    boolean canContainFocusOwner(Component focusOwnerCandidate) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   583
        if (!(isEnabled() && isDisplayable()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   584
              && isVisible() && isFocusable()))
90ce3da70b43 Initial load
duke
parents:
diff changeset
   585
        {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   586
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   587
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   588
        if (isFocusCycleRoot()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   589
            FocusTraversalPolicy policy = getFocusTraversalPolicy();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   590
            if (policy instanceof DefaultFocusTraversalPolicy) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   591
                if (!((DefaultFocusTraversalPolicy)policy).accept(focusOwnerCandidate)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   592
                    return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   593
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   594
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   595
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   596
        synchronized(getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   597
            if (parent != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   598
                return parent.canContainFocusOwner(focusOwnerCandidate);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   599
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   600
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   601
        return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   602
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   603
90ce3da70b43 Initial load
duke
parents:
diff changeset
   604
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   605
     * Checks whether or not this container has heavyweight children.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   606
     * Note: Should be called while holding tree lock
90ce3da70b43 Initial load
duke
parents:
diff changeset
   607
     * @return true if there is at least one heavyweight children in a container, false otherwise
90ce3da70b43 Initial load
duke
parents:
diff changeset
   608
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
   609
     */
1978
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
   610
    final boolean hasHeavyweightDescendants() {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   611
        checkTreeLock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   612
        return numOfHWComponents > 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   613
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   614
90ce3da70b43 Initial load
duke
parents:
diff changeset
   615
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   616
     * Checks whether or not this container has lightweight children.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   617
     * Note: Should be called while holding tree lock
90ce3da70b43 Initial load
duke
parents:
diff changeset
   618
     * @return true if there is at least one lightweight children in a container, false otherwise
90ce3da70b43 Initial load
duke
parents:
diff changeset
   619
     * @since 1.7
90ce3da70b43 Initial load
duke
parents:
diff changeset
   620
     */
1978
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
   621
    final boolean hasLightweightDescendants() {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   622
        checkTreeLock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   623
        return numOfLWComponents > 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   624
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   625
90ce3da70b43 Initial load
duke
parents:
diff changeset
   626
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   627
     * Returns closest heavyweight component to this container. If this container is heavyweight
90ce3da70b43 Initial load
duke
parents:
diff changeset
   628
     * returns this.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   629
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
   630
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   631
    Container getHeavyweightContainer() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   632
        checkTreeLock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   633
        if (peer != null && !(peer instanceof LightweightPeer)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   634
            return this;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   635
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   636
            return getNativeContainer();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   637
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   638
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   639
90ce3da70b43 Initial load
duke
parents:
diff changeset
   640
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   641
     * Detects whether or not remove from current parent and adding to new parent requires call of
90ce3da70b43 Initial load
duke
parents:
diff changeset
   642
     * removeNotify on the component. Since removeNotify destroys native window this might (not)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   643
     * be required. For example, if new container and old containers are the same we don't need to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   644
     * destroy native window.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   645
     * @since: 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
   646
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   647
    private static boolean isRemoveNotifyNeeded(Component comp, Container oldContainer, Container newContainer) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   648
        if (oldContainer == null) { // Component didn't have parent - no removeNotify
90ce3da70b43 Initial load
duke
parents:
diff changeset
   649
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   650
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   651
        if (comp.peer == null) { // Component didn't have peer - no removeNotify
90ce3da70b43 Initial load
duke
parents:
diff changeset
   652
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   653
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   654
        if (newContainer.peer == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   655
            // Component has peer but new Container doesn't - call removeNotify
90ce3da70b43 Initial load
duke
parents:
diff changeset
   656
            return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   657
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   658
90ce3da70b43 Initial load
duke
parents:
diff changeset
   659
        // If component is lightweight non-Container or lightweight Container with all but heavyweight
90ce3da70b43 Initial load
duke
parents:
diff changeset
   660
        // children there is no need to call remove notify
90ce3da70b43 Initial load
duke
parents:
diff changeset
   661
        if (comp.isLightweight()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   662
            boolean isContainer = comp instanceof Container;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   663
90ce3da70b43 Initial load
duke
parents:
diff changeset
   664
            if (!isContainer || (isContainer && !((Container)comp).hasHeavyweightDescendants())) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   665
                return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   666
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   667
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   668
90ce3da70b43 Initial load
duke
parents:
diff changeset
   669
        // If this point is reached, then the comp is either a HW or a LW container with HW descendants.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   670
90ce3da70b43 Initial load
duke
parents:
diff changeset
   671
        // All three components have peers, check for peer change
90ce3da70b43 Initial load
duke
parents:
diff changeset
   672
        Container newNativeContainer = oldContainer.getHeavyweightContainer();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   673
        Container oldNativeContainer = newContainer.getHeavyweightContainer();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   674
        if (newNativeContainer != oldNativeContainer) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   675
            // Native containers change - check whether or not current platform supports
90ce3da70b43 Initial load
duke
parents:
diff changeset
   676
            // changing of widget hierarchy on native level without recreation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   677
            // The current implementation forbids reparenting of LW containers with HW descendants
90ce3da70b43 Initial load
duke
parents:
diff changeset
   678
            // into another native container w/o destroying the peers. Actually such an operation
90ce3da70b43 Initial load
duke
parents:
diff changeset
   679
            // is quite rare. If we ever need to save the peers, we'll have to slightly change the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   680
            // addDelicately() method in order to handle such LW containers recursively, reparenting
90ce3da70b43 Initial load
duke
parents:
diff changeset
   681
            // each HW descendant independently.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   682
            return !comp.peer.isReparentSupported();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   683
        } else {
2462
192552ca8292 6809227: poor performance on Panel.Add() method in jdk6
dcherepanov
parents: 2461
diff changeset
   684
            return false;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   685
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   686
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   687
90ce3da70b43 Initial load
duke
parents:
diff changeset
   688
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   689
     * Moves the specified component to the specified z-order index in
90ce3da70b43 Initial load
duke
parents:
diff changeset
   690
     * the container. The z-order determines the order that components
90ce3da70b43 Initial load
duke
parents:
diff changeset
   691
     * are painted; the component with the highest z-order paints first
90ce3da70b43 Initial load
duke
parents:
diff changeset
   692
     * and the component with the lowest z-order paints last.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   693
     * Where components overlap, the component with the lower
90ce3da70b43 Initial load
duke
parents:
diff changeset
   694
     * z-order paints over the component with the higher z-order.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   695
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   696
     * If the component is a child of some other container, it is
90ce3da70b43 Initial load
duke
parents:
diff changeset
   697
     * removed from that container before being added to this container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   698
     * The important difference between this method and
90ce3da70b43 Initial load
duke
parents:
diff changeset
   699
     * <code>java.awt.Container.add(Component, int)</code> is that this method
90ce3da70b43 Initial load
duke
parents:
diff changeset
   700
     * doesn't call <code>removeNotify</code> on the component while
90ce3da70b43 Initial load
duke
parents:
diff changeset
   701
     * removing it from its previous container unless necessary and when
90ce3da70b43 Initial load
duke
parents:
diff changeset
   702
     * allowed by the underlying native windowing system. This way, if the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   703
     * component has the keyboard focus, it maintains the focus when
90ce3da70b43 Initial load
duke
parents:
diff changeset
   704
     * moved to the new position.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   705
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   706
     * This property is guaranteed to apply only to lightweight
90ce3da70b43 Initial load
duke
parents:
diff changeset
   707
     * non-<code>Container</code> components.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   708
     * <p>
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   709
     * This method changes layout-related information, and therefore,
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   710
     * invalidates the component hierarchy.
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   711
     * <p>
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   712
     * <b>Note</b>: Not all platforms support changing the z-order of
90ce3da70b43 Initial load
duke
parents:
diff changeset
   713
     * heavyweight components from one container into another without
90ce3da70b43 Initial load
duke
parents:
diff changeset
   714
     * the call to <code>removeNotify</code>. There is no way to detect
90ce3da70b43 Initial load
duke
parents:
diff changeset
   715
     * whether a platform supports this, so developers shouldn't make
90ce3da70b43 Initial load
duke
parents:
diff changeset
   716
     * any assumptions.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   717
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   718
     * @param     comp the component to be moved
90ce3da70b43 Initial load
duke
parents:
diff changeset
   719
     * @param     index the position in the container's list to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   720
     *            insert the component, where <code>getComponentCount()</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   721
     *            appends to the end
90ce3da70b43 Initial load
duke
parents:
diff changeset
   722
     * @exception NullPointerException if <code>comp</code> is
90ce3da70b43 Initial load
duke
parents:
diff changeset
   723
     *            <code>null</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   724
     * @exception IllegalArgumentException if <code>comp</code> is one of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
   725
     *            container's parents
90ce3da70b43 Initial load
duke
parents:
diff changeset
   726
     * @exception IllegalArgumentException if <code>index</code> is not in
90ce3da70b43 Initial load
duke
parents:
diff changeset
   727
     *            the range <code>[0, getComponentCount()]</code> for moving
90ce3da70b43 Initial load
duke
parents:
diff changeset
   728
     *            between containers, or not in the range
90ce3da70b43 Initial load
duke
parents:
diff changeset
   729
     *            <code>[0, getComponentCount()-1]</code> for moving inside
90ce3da70b43 Initial load
duke
parents:
diff changeset
   730
     *            a container
90ce3da70b43 Initial load
duke
parents:
diff changeset
   731
     * @exception IllegalArgumentException if adding a container to itself
90ce3da70b43 Initial load
duke
parents:
diff changeset
   732
     * @exception IllegalArgumentException if adding a <code>Window</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   733
     *            to a container
90ce3da70b43 Initial load
duke
parents:
diff changeset
   734
     * @see #getComponentZOrder(java.awt.Component)
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   735
     * @see #invalidate
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   736
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
   737
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   738
    public void setComponentZOrder(Component comp, int index) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   739
         synchronized (getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   740
             // Store parent because remove will clear it
90ce3da70b43 Initial load
duke
parents:
diff changeset
   741
             Container curParent = comp.parent;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   742
             int oldZindex = getComponentZOrder(comp);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   743
90ce3da70b43 Initial load
duke
parents:
diff changeset
   744
             if (curParent == this && index == oldZindex) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   745
                 return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   746
             }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   747
             checkAdding(comp, index);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   748
90ce3da70b43 Initial load
duke
parents:
diff changeset
   749
             boolean peerRecreated = (curParent != null) ?
90ce3da70b43 Initial load
duke
parents:
diff changeset
   750
                 curParent.removeDelicately(comp, this, index) : false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   751
90ce3da70b43 Initial load
duke
parents:
diff changeset
   752
             addDelicately(comp, curParent, index);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   753
90ce3da70b43 Initial load
duke
parents:
diff changeset
   754
             // If the oldZindex == -1, the component gets inserted,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   755
             // rather than it changes its z-order.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   756
             if (!peerRecreated && oldZindex != -1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   757
                 // The new 'index' cannot be == -1.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   758
                 // It gets checked at the checkAdding() method.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   759
                 // Therefore both oldZIndex and index denote
90ce3da70b43 Initial load
duke
parents:
diff changeset
   760
                 // some existing positions at this point and
90ce3da70b43 Initial load
duke
parents:
diff changeset
   761
                 // this is actually a Z-order changing.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   762
                 comp.mixOnZOrderChanging(oldZindex, index);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   763
             }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   764
         }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   765
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   766
90ce3da70b43 Initial load
duke
parents:
diff changeset
   767
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   768
     * Traverses the tree of components and reparents children heavyweight component
90ce3da70b43 Initial load
duke
parents:
diff changeset
   769
     * to new heavyweight parent.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   770
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
   771
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   772
    private void reparentTraverse(ContainerPeer parentPeer, Container child) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   773
        checkTreeLock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   774
90ce3da70b43 Initial load
duke
parents:
diff changeset
   775
        for (int i = 0; i < child.getComponentCount(); i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   776
            Component comp = child.getComponent(i);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   777
            if (comp.isLightweight()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   778
                // If components is lightweight check if it is container
90ce3da70b43 Initial load
duke
parents:
diff changeset
   779
                // If it is container it might contain heavyweight children we need to reparent
90ce3da70b43 Initial load
duke
parents:
diff changeset
   780
                if (comp instanceof Container) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   781
                    reparentTraverse(parentPeer, (Container)comp);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   782
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   783
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   784
                // Q: Need to update NativeInLightFixer?
90ce3da70b43 Initial load
duke
parents:
diff changeset
   785
                comp.getPeer().reparent(parentPeer);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   786
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   787
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   788
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   789
90ce3da70b43 Initial load
duke
parents:
diff changeset
   790
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   791
     * Reparents child component peer to this container peer.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   792
     * Container must be heavyweight.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   793
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
   794
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   795
    private void reparentChild(Component comp) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   796
        checkTreeLock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   797
        if (comp == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   798
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   799
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   800
        if (comp.isLightweight()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   801
            // If component is lightweight container we need to reparent all its explicit  heavyweight children
90ce3da70b43 Initial load
duke
parents:
diff changeset
   802
            if (comp instanceof Container) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   803
                // Traverse component's tree till depth-first until encountering heavyweight component
90ce3da70b43 Initial load
duke
parents:
diff changeset
   804
                reparentTraverse((ContainerPeer)getPeer(), (Container)comp);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   805
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   806
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   807
            comp.getPeer().reparent((ContainerPeer)getPeer());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   808
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   809
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   810
90ce3da70b43 Initial load
duke
parents:
diff changeset
   811
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   812
     * Adds component to this container. Tries to minimize side effects of this adding -
90ce3da70b43 Initial load
duke
parents:
diff changeset
   813
     * doesn't call remove notify if it is not required.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   814
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
   815
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   816
    private void addDelicately(Component comp, Container curParent, int index) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   817
        checkTreeLock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   818
90ce3da70b43 Initial load
duke
parents:
diff changeset
   819
        // Check if moving between containers
90ce3da70b43 Initial load
duke
parents:
diff changeset
   820
        if (curParent != this) {
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   821
            //index == -1 means add to the end.
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   822
            if (index == -1) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   823
                component.add(comp);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   824
            } else {
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   825
                component.add(index, comp);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   826
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   827
            comp.parent = this;
2459
08f3416ff334 6804747: Ensure consistent graphicsConfig member across components hierarchy
anthony
parents: 2451
diff changeset
   828
            comp.setGraphicsConfiguration(getGraphicsConfiguration());
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   829
90ce3da70b43 Initial load
duke
parents:
diff changeset
   830
            adjustListeningChildren(AWTEvent.HIERARCHY_EVENT_MASK,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   831
                                    comp.numListening(AWTEvent.HIERARCHY_EVENT_MASK));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   832
            adjustListeningChildren(AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   833
                                    comp.numListening(AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   834
            adjustDescendants(comp.countHierarchyMembers());
90ce3da70b43 Initial load
duke
parents:
diff changeset
   835
        } else {
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   836
            if (index < component.size()) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   837
                component.set(index, comp);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   838
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   839
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   840
1183
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
   841
        invalidateIfValid();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   842
        if (peer != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   843
            if (comp.peer == null) { // Remove notify was called or it didn't have peer - create new one
90ce3da70b43 Initial load
duke
parents:
diff changeset
   844
                comp.addNotify();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   845
            } else { // Both container and child have peers, it means child peer should be reparented.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   846
                // In both cases we need to reparent native widgets.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   847
                Container newNativeContainer = getHeavyweightContainer();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   848
                Container oldNativeContainer = curParent.getHeavyweightContainer();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   849
                if (oldNativeContainer != newNativeContainer) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   850
                    // Native container changed - need to reparent native widgets
90ce3da70b43 Initial load
duke
parents:
diff changeset
   851
                    newNativeContainer.reparentChild(comp);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   852
                }
2647
ea80a312972e 6825362: Avoid calling peer.setZOrder on Window instances
dcherepanov
parents: 2644
diff changeset
   853
                comp.updateZOrder();
2462
192552ca8292 6809227: poor performance on Panel.Add() method in jdk6
dcherepanov
parents: 2461
diff changeset
   854
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   855
                if (!comp.isLightweight() && isLightweight()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   856
                    // If component is heavyweight and one of the containers is lightweight
130
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
   857
                    // the location of the component should be fixed.
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
   858
                    comp.relocateComponent();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   859
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   860
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   861
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   862
        if (curParent != this) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   863
            /* Notify the layout manager of the added component. */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   864
            if (layoutMgr != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   865
                if (layoutMgr instanceof LayoutManager2) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   866
                    ((LayoutManager2)layoutMgr).addLayoutComponent(comp, null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   867
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   868
                    layoutMgr.addLayoutComponent(null, comp);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   869
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   870
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   871
            if (containerListener != null ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
   872
                (eventMask & AWTEvent.CONTAINER_EVENT_MASK) != 0 ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
   873
                Toolkit.enabledOnToolkit(AWTEvent.CONTAINER_EVENT_MASK)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   874
                ContainerEvent e = new ContainerEvent(this,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   875
                                                      ContainerEvent.COMPONENT_ADDED,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   876
                                                      comp);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   877
                dispatchEvent(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   878
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   879
            comp.createHierarchyEvents(HierarchyEvent.HIERARCHY_CHANGED, comp,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   880
                                       this, HierarchyEvent.PARENT_CHANGED,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   881
                                       Toolkit.enabledOnToolkit(AWTEvent.HIERARCHY_EVENT_MASK));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   882
90ce3da70b43 Initial load
duke
parents:
diff changeset
   883
            // If component is focus owner or parent container of focus owner check that after reparenting
90ce3da70b43 Initial load
duke
parents:
diff changeset
   884
            // focus owner moved out if new container prohibit this kind of focus owner.
1171
a2782dd9f312 4685768: A11y issue - Focus set to disabled component, can't Tab/Shift-Tab
ant
parents: 441
diff changeset
   885
            if (comp.isFocusOwner() && !comp.canBeFocusOwnerRecursively()) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   886
                comp.transferFocus();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   887
            } else if (comp instanceof Container) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   888
                Component focusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
1171
a2782dd9f312 4685768: A11y issue - Focus set to disabled component, can't Tab/Shift-Tab
ant
parents: 441
diff changeset
   889
                if (focusOwner != null && isParentOf(focusOwner) && !focusOwner.canBeFocusOwnerRecursively()) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   890
                    focusOwner.transferFocus();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   891
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   892
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   893
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   894
            comp.createHierarchyEvents(HierarchyEvent.HIERARCHY_CHANGED, comp,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   895
                                       this, HierarchyEvent.HIERARCHY_CHANGED,
90ce3da70b43 Initial load
duke
parents:
diff changeset
   896
                                       Toolkit.enabledOnToolkit(AWTEvent.HIERARCHY_EVENT_MASK));
90ce3da70b43 Initial load
duke
parents:
diff changeset
   897
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   898
90ce3da70b43 Initial load
duke
parents:
diff changeset
   899
        if (peer != null && layoutMgr == null && isVisible()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   900
            updateCursorImmediately();
90ce3da70b43 Initial load
duke
parents:
diff changeset
   901
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   902
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   903
90ce3da70b43 Initial load
duke
parents:
diff changeset
   904
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   905
     * Returns the z-order index of the component inside the container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   906
     * The higher a component is in the z-order hierarchy, the lower
90ce3da70b43 Initial load
duke
parents:
diff changeset
   907
     * its index.  The component with the lowest z-order index is
90ce3da70b43 Initial load
duke
parents:
diff changeset
   908
     * painted last, above all other child components.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   909
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   910
     * @param comp the component being queried
90ce3da70b43 Initial load
duke
parents:
diff changeset
   911
     * @return  the z-order index of the component; otherwise
90ce3da70b43 Initial load
duke
parents:
diff changeset
   912
     *          returns -1 if the component is <code>null</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   913
     *          or doesn't belong to the container
90ce3da70b43 Initial load
duke
parents:
diff changeset
   914
     * @see #setComponentZOrder(java.awt.Component, int)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   915
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
   916
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   917
    public int getComponentZOrder(Component comp) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   918
        if (comp == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   919
            return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   920
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   921
        synchronized(getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   922
            // Quick check - container should be immediate parent of the component
90ce3da70b43 Initial load
duke
parents:
diff changeset
   923
            if (comp.parent != this) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   924
                return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
   925
            }
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
   926
            return component.indexOf(comp);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   927
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   928
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   929
90ce3da70b43 Initial load
duke
parents:
diff changeset
   930
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   931
     * Adds the specified component to the end of this container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   932
     * Also notifies the layout manager to add the component to
90ce3da70b43 Initial load
duke
parents:
diff changeset
   933
     * this container's layout using the specified constraints object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   934
     * This is a convenience method for {@link #addImpl}.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   935
     * <p>
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   936
     * This method changes layout-related information, and therefore,
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   937
     * invalidates the component hierarchy. If the container has already been
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   938
     * displayed, the hierarchy must be validated thereafter in order to
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   939
     * display the added component.
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   940
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   941
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   942
     * @param     comp the component to be added
90ce3da70b43 Initial load
duke
parents:
diff changeset
   943
     * @param     constraints an object expressing
90ce3da70b43 Initial load
duke
parents:
diff changeset
   944
     *                  layout contraints for this component
90ce3da70b43 Initial load
duke
parents:
diff changeset
   945
     * @exception NullPointerException if {@code comp} is {@code null}
90ce3da70b43 Initial load
duke
parents:
diff changeset
   946
     * @see #addImpl
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   947
     * @see #invalidate
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   948
     * @see #validate
90ce3da70b43 Initial load
duke
parents:
diff changeset
   949
     * @see javax.swing.JComponent#revalidate()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   950
     * @see       LayoutManager
90ce3da70b43 Initial load
duke
parents:
diff changeset
   951
     * @since     JDK1.1
90ce3da70b43 Initial load
duke
parents:
diff changeset
   952
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   953
    public void add(Component comp, Object constraints) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   954
        addImpl(comp, constraints, -1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   955
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   956
90ce3da70b43 Initial load
duke
parents:
diff changeset
   957
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   958
     * Adds the specified component to this container with the specified
90ce3da70b43 Initial load
duke
parents:
diff changeset
   959
     * constraints at the specified index.  Also notifies the layout
90ce3da70b43 Initial load
duke
parents:
diff changeset
   960
     * manager to add the component to the this container's layout using
90ce3da70b43 Initial load
duke
parents:
diff changeset
   961
     * the specified constraints object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   962
     * This is a convenience method for {@link #addImpl}.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   963
     * <p>
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   964
     * This method changes layout-related information, and therefore,
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   965
     * invalidates the component hierarchy. If the container has already been
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   966
     * displayed, the hierarchy must be validated thereafter in order to
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   967
     * display the added component.
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   968
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   969
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
   970
     * @param comp the component to be added
90ce3da70b43 Initial load
duke
parents:
diff changeset
   971
     * @param constraints an object expressing layout contraints for this
90ce3da70b43 Initial load
duke
parents:
diff changeset
   972
     * @param index the position in the container's list at which to insert
90ce3da70b43 Initial load
duke
parents:
diff changeset
   973
     * the component; <code>-1</code> means insert at the end
90ce3da70b43 Initial load
duke
parents:
diff changeset
   974
     * component
90ce3da70b43 Initial load
duke
parents:
diff changeset
   975
     * @exception NullPointerException if {@code comp} is {@code null}
90ce3da70b43 Initial load
duke
parents:
diff changeset
   976
     * @exception IllegalArgumentException if {@code index} is invalid (see
90ce3da70b43 Initial load
duke
parents:
diff changeset
   977
     *            {@link #addImpl} for details)
90ce3da70b43 Initial load
duke
parents:
diff changeset
   978
     * @see #addImpl
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
   979
     * @see #invalidate
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
   980
     * @see #validate
90ce3da70b43 Initial load
duke
parents:
diff changeset
   981
     * @see javax.swing.JComponent#revalidate()
90ce3da70b43 Initial load
duke
parents:
diff changeset
   982
     * @see #remove
90ce3da70b43 Initial load
duke
parents:
diff changeset
   983
     * @see LayoutManager
90ce3da70b43 Initial load
duke
parents:
diff changeset
   984
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
   985
    public void add(Component comp, Object constraints, int index) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
   986
       addImpl(comp, constraints, index);
90ce3da70b43 Initial load
duke
parents:
diff changeset
   987
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
   988
90ce3da70b43 Initial load
duke
parents:
diff changeset
   989
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
   990
     * Adds the specified component to this container at the specified
90ce3da70b43 Initial load
duke
parents:
diff changeset
   991
     * index. This method also notifies the layout manager to add
90ce3da70b43 Initial load
duke
parents:
diff changeset
   992
     * the component to this container's layout using the specified
90ce3da70b43 Initial load
duke
parents:
diff changeset
   993
     * constraints object via the <code>addLayoutComponent</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   994
     * method.
90ce3da70b43 Initial load
duke
parents:
diff changeset
   995
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
   996
     * The constraints are
90ce3da70b43 Initial load
duke
parents:
diff changeset
   997
     * defined by the particular layout manager being used.  For
90ce3da70b43 Initial load
duke
parents:
diff changeset
   998
     * example, the <code>BorderLayout</code> class defines five
90ce3da70b43 Initial load
duke
parents:
diff changeset
   999
     * constraints: <code>BorderLayout.NORTH</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1000
     * <code>BorderLayout.SOUTH</code>, <code>BorderLayout.EAST</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1001
     * <code>BorderLayout.WEST</code>, and <code>BorderLayout.CENTER</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1002
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1003
     * The <code>GridBagLayout</code> class requires a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1004
     * <code>GridBagConstraints</code> object.  Failure to pass
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1005
     * the correct type of constraints object results in an
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1006
     * <code>IllegalArgumentException</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1007
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1008
     * If the current layout manager implements {@code LayoutManager2}, then
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1009
     * {@link LayoutManager2#addLayoutComponent(Component,Object)} is invoked on
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1010
     * it. If the current layout manager does not implement
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1011
     * {@code LayoutManager2}, and constraints is a {@code String}, then
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1012
     * {@link LayoutManager#addLayoutComponent(String,Component)} is invoked on it.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1013
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1014
     * If the component is not an ancestor of this container and has a non-null
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1015
     * parent, it is removed from its current parent before it is added to this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1016
     * container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1017
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1018
     * This is the method to override if a program needs to track
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1019
     * every add request to a container as all other add methods defer
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1020
     * to this one. An overriding method should
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1021
     * usually include a call to the superclass's version of the method:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1022
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1023
     * <blockquote>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1024
     * <code>super.addImpl(comp, constraints, index)</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1025
     * </blockquote>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1026
     * <p>
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1027
     * This method changes layout-related information, and therefore,
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1028
     * invalidates the component hierarchy. If the container has already been
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1029
     * displayed, the hierarchy must be validated thereafter in order to
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1030
     * display the added component.
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1031
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1032
     * @param     comp       the component to be added
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1033
     * @param     constraints an object expressing layout constraints
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1034
     *                 for this component
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1035
     * @param     index the position in the container's list at which to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1036
     *                 insert the component, where <code>-1</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1037
     *                 means append to the end
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1038
     * @exception IllegalArgumentException if {@code index} is invalid;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1039
     *            if {@code comp} is a child of this container, the valid
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1040
     *            range is {@code [-1, getComponentCount()-1]}; if component is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1041
     *            not a child of this container, the valid range is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1042
     *            {@code [-1, getComponentCount()]}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1043
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1044
     * @exception IllegalArgumentException if {@code comp} is an ancestor of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1045
     *                                     this container
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1046
     * @exception IllegalArgumentException if adding a window to a container
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1047
     * @exception NullPointerException if {@code comp} is {@code null}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1048
     * @see       #add(Component)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1049
     * @see       #add(Component, int)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1050
     * @see       #add(Component, java.lang.Object)
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1051
     * @see #invalidate
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1052
     * @see       LayoutManager
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1053
     * @see       LayoutManager2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1054
     * @since     JDK1.1
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1055
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1056
    protected void addImpl(Component comp, Object constraints, int index) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1057
        synchronized (getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1058
            /* Check for correct arguments:  index in bounds,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1059
             * comp cannot be one of this container's parents,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1060
             * and comp cannot be a window.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1061
             * comp and container must be on the same GraphicsDevice.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1062
             * if comp is container, all sub-components must be on
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1063
             * same GraphicsDevice.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1064
             */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1065
            GraphicsConfiguration thisGC = this.getGraphicsConfiguration();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1066
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1067
            if (index > component.size() || (index < 0 && index != -1)) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1068
                throw new IllegalArgumentException(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1069
                          "illegal component position");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1070
            }
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1071
            checkAddToSelf(comp);
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1072
            checkNotAWindow(comp);
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  1073
            if (thisGC != null) {
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  1074
                comp.checkGD(thisGC.getDevice().getIDstring());
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  1075
            }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1076
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1077
            /* Reparent the component and tidy up the tree's state. */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1078
            if (comp.parent != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1079
                comp.parent.remove(comp);
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1080
                    if (index > component.size()) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1081
                        throw new IllegalArgumentException("illegal component position");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1082
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1083
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1084
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1085
            //index == -1 means add to the end.
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1086
            if (index == -1) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1087
                component.add(comp);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1088
            } else {
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1089
                component.add(index, comp);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1090
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1091
            comp.parent = this;
2459
08f3416ff334 6804747: Ensure consistent graphicsConfig member across components hierarchy
anthony
parents: 2451
diff changeset
  1092
            comp.setGraphicsConfiguration(thisGC);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1093
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1094
            adjustListeningChildren(AWTEvent.HIERARCHY_EVENT_MASK,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1095
                comp.numListening(AWTEvent.HIERARCHY_EVENT_MASK));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1096
            adjustListeningChildren(AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1097
                comp.numListening(AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1098
            adjustDescendants(comp.countHierarchyMembers());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1099
1183
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  1100
            invalidateIfValid();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1101
            if (peer != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1102
                comp.addNotify();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1103
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1104
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1105
            /* Notify the layout manager of the added component. */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1106
            if (layoutMgr != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1107
                if (layoutMgr instanceof LayoutManager2) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1108
                    ((LayoutManager2)layoutMgr).addLayoutComponent(comp, constraints);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1109
                } else if (constraints instanceof String) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1110
                    layoutMgr.addLayoutComponent((String)constraints, comp);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1111
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1112
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1113
            if (containerListener != null ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1114
                (eventMask & AWTEvent.CONTAINER_EVENT_MASK) != 0 ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1115
                Toolkit.enabledOnToolkit(AWTEvent.CONTAINER_EVENT_MASK)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1116
                ContainerEvent e = new ContainerEvent(this,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1117
                                     ContainerEvent.COMPONENT_ADDED,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1118
                                     comp);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1119
                dispatchEvent(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1120
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1121
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1122
            comp.createHierarchyEvents(HierarchyEvent.HIERARCHY_CHANGED, comp,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1123
                                       this, HierarchyEvent.PARENT_CHANGED,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1124
                                       Toolkit.enabledOnToolkit(AWTEvent.HIERARCHY_EVENT_MASK));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1125
            if (peer != null && layoutMgr == null && isVisible()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1126
                updateCursorImmediately();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1127
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1128
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1129
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1130
2459
08f3416ff334 6804747: Ensure consistent graphicsConfig member across components hierarchy
anthony
parents: 2451
diff changeset
  1131
    @Override
2805
9f18d7e66042 6812298: Dynamic GraphicsConfig changes don't work on X11 platforms
anthony
parents: 2647
diff changeset
  1132
    boolean updateGraphicsData(GraphicsConfiguration gc) {
9f18d7e66042 6812298: Dynamic GraphicsConfig changes don't work on X11 platforms
anthony
parents: 2647
diff changeset
  1133
        checkTreeLock();
9f18d7e66042 6812298: Dynamic GraphicsConfig changes don't work on X11 platforms
anthony
parents: 2647
diff changeset
  1134
9f18d7e66042 6812298: Dynamic GraphicsConfig changes don't work on X11 platforms
anthony
parents: 2647
diff changeset
  1135
        boolean ret = super.updateGraphicsData(gc);
9f18d7e66042 6812298: Dynamic GraphicsConfig changes don't work on X11 platforms
anthony
parents: 2647
diff changeset
  1136
9f18d7e66042 6812298: Dynamic GraphicsConfig changes don't work on X11 platforms
anthony
parents: 2647
diff changeset
  1137
        for (Component comp : component) {
9f18d7e66042 6812298: Dynamic GraphicsConfig changes don't work on X11 platforms
anthony
parents: 2647
diff changeset
  1138
            if (comp != null) {
9f18d7e66042 6812298: Dynamic GraphicsConfig changes don't work on X11 platforms
anthony
parents: 2647
diff changeset
  1139
                ret |= comp.updateGraphicsData(gc);
2459
08f3416ff334 6804747: Ensure consistent graphicsConfig member across components hierarchy
anthony
parents: 2451
diff changeset
  1140
            }
08f3416ff334 6804747: Ensure consistent graphicsConfig member across components hierarchy
anthony
parents: 2451
diff changeset
  1141
        }
2805
9f18d7e66042 6812298: Dynamic GraphicsConfig changes don't work on X11 platforms
anthony
parents: 2647
diff changeset
  1142
        return ret;
2459
08f3416ff334 6804747: Ensure consistent graphicsConfig member across components hierarchy
anthony
parents: 2451
diff changeset
  1143
    }
08f3416ff334 6804747: Ensure consistent graphicsConfig member across components hierarchy
anthony
parents: 2451
diff changeset
  1144
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1145
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1146
     * Checks that all Components that this Container contains are on
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1147
     * the same GraphicsDevice as this Container.  If not, throws an
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1148
     * IllegalArgumentException.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1149
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1150
    void checkGD(String stringID) {
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1151
        for (Component comp : component) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1152
            if (comp != null) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1153
                comp.checkGD(stringID);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1154
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1155
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1156
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1157
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1158
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1159
     * Removes the component, specified by <code>index</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1160
     * from this container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1161
     * This method also notifies the layout manager to remove the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1162
     * component from this container's layout via the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1163
     * <code>removeLayoutComponent</code> method.
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1164
     * <p>
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1165
     * This method changes layout-related information, and therefore,
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1166
     * invalidates the component hierarchy. If the container has already been
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1167
     * displayed, the hierarchy must be validated thereafter in order to
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1168
     * reflect the changes.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1169
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1170
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1171
     * @param     index   the index of the component to be removed
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1172
     * @throws ArrayIndexOutOfBoundsException if {@code index} is not in
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1173
     *         range {@code [0, getComponentCount()-1]}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1174
     * @see #add
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1175
     * @see #invalidate
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1176
     * @see #validate
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1177
     * @see #getComponentCount
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1178
     * @since JDK1.1
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1179
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1180
    public void remove(int index) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1181
        synchronized (getTreeLock()) {
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1182
            if (index < 0  || index >= component.size()) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1183
                throw new ArrayIndexOutOfBoundsException(index);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1184
            }
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1185
            Component comp = component.get(index);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1186
            if (peer != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1187
                comp.removeNotify();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1188
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1189
            if (layoutMgr != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1190
                layoutMgr.removeLayoutComponent(comp);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1191
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1192
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1193
            adjustListeningChildren(AWTEvent.HIERARCHY_EVENT_MASK,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1194
                -comp.numListening(AWTEvent.HIERARCHY_EVENT_MASK));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1195
            adjustListeningChildren(AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1196
                -comp.numListening(AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1197
            adjustDescendants(-(comp.countHierarchyMembers()));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1198
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1199
            comp.parent = null;
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1200
            component.remove(index);
2459
08f3416ff334 6804747: Ensure consistent graphicsConfig member across components hierarchy
anthony
parents: 2451
diff changeset
  1201
            comp.setGraphicsConfiguration(null);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1202
1183
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  1203
            invalidateIfValid();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1204
            if (containerListener != null ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1205
                (eventMask & AWTEvent.CONTAINER_EVENT_MASK) != 0 ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1206
                Toolkit.enabledOnToolkit(AWTEvent.CONTAINER_EVENT_MASK)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1207
                ContainerEvent e = new ContainerEvent(this,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1208
                                     ContainerEvent.COMPONENT_REMOVED,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1209
                                     comp);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1210
                dispatchEvent(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1211
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1212
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1213
            comp.createHierarchyEvents(HierarchyEvent.HIERARCHY_CHANGED, comp,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1214
                                       this, HierarchyEvent.PARENT_CHANGED,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1215
                                       Toolkit.enabledOnToolkit(AWTEvent.HIERARCHY_EVENT_MASK));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1216
            if (peer != null && layoutMgr == null && isVisible()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1217
                updateCursorImmediately();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1218
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1219
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1220
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1221
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1222
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1223
     * Removes the specified component from this container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1224
     * This method also notifies the layout manager to remove the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1225
     * component from this container's layout via the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1226
     * <code>removeLayoutComponent</code> method.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1227
     * <p>
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1228
     * This method changes layout-related information, and therefore,
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1229
     * invalidates the component hierarchy. If the container has already been
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1230
     * displayed, the hierarchy must be validated thereafter in order to
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1231
     * reflect the changes.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1232
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1233
     * @param comp the component to be removed
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1234
     * @see #add
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1235
     * @see #invalidate
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1236
     * @see #validate
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1237
     * @see #remove(int)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1238
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1239
    public void remove(Component comp) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1240
        synchronized (getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1241
            if (comp.parent == this)  {
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1242
                int index = component.indexOf(comp);
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1243
                if (index >= 0) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1244
                    remove(index);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1245
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1246
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1247
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1248
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1249
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1250
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1251
     * Removes all the components from this container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1252
     * This method also notifies the layout manager to remove the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1253
     * components from this container's layout via the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1254
     * <code>removeLayoutComponent</code> method.
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1255
     * <p>
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1256
     * This method changes layout-related information, and therefore,
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1257
     * invalidates the component hierarchy. If the container has already been
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1258
     * displayed, the hierarchy must be validated thereafter in order to
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1259
     * reflect the changes.
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1260
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1261
     * @see #add
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1262
     * @see #remove
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1263
     * @see #invalidate
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1264
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1265
    public void removeAll() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1266
        synchronized (getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1267
            adjustListeningChildren(AWTEvent.HIERARCHY_EVENT_MASK,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1268
                                    -listeningChildren);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1269
            adjustListeningChildren(AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1270
                                    -listeningBoundsChildren);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1271
            adjustDescendants(-descendantsCount);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1272
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1273
            while (!component.isEmpty()) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1274
                Component comp = component.remove(component.size()-1);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1275
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1276
                if (peer != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1277
                    comp.removeNotify();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1278
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1279
                if (layoutMgr != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1280
                    layoutMgr.removeLayoutComponent(comp);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1281
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1282
                comp.parent = null;
2459
08f3416ff334 6804747: Ensure consistent graphicsConfig member across components hierarchy
anthony
parents: 2451
diff changeset
  1283
                comp.setGraphicsConfiguration(null);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1284
                if (containerListener != null ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1285
                   (eventMask & AWTEvent.CONTAINER_EVENT_MASK) != 0 ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1286
                    Toolkit.enabledOnToolkit(AWTEvent.CONTAINER_EVENT_MASK)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1287
                    ContainerEvent e = new ContainerEvent(this,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1288
                                     ContainerEvent.COMPONENT_REMOVED,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1289
                                     comp);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1290
                    dispatchEvent(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1291
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1292
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1293
                comp.createHierarchyEvents(HierarchyEvent.HIERARCHY_CHANGED,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1294
                                           comp, this,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1295
                                           HierarchyEvent.PARENT_CHANGED,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1296
                                           Toolkit.enabledOnToolkit(AWTEvent.HIERARCHY_EVENT_MASK));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1297
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1298
            if (peer != null && layoutMgr == null && isVisible()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1299
                updateCursorImmediately();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1300
            }
1183
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  1301
            invalidateIfValid();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1302
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1303
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1304
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1305
    // Should only be called while holding tree lock
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1306
    int numListening(long mask) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1307
        int superListening = super.numListening(mask);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1308
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1309
        if (mask == AWTEvent.HIERARCHY_EVENT_MASK) {
3938
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
  1310
            if (eventLog.isLoggable(PlatformLogger.FINE)) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1311
                // Verify listeningChildren is correct
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1312
                int sum = 0;
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1313
                for (Component comp : component) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1314
                    sum += comp.numListening(mask);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1315
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1316
                if (listeningChildren != sum) {
3938
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
  1317
                    eventLog.fine("Assertion (listeningChildren == sum) failed");
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1318
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1319
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1320
            return listeningChildren + superListening;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1321
        } else if (mask == AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK) {
3938
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
  1322
            if (eventLog.isLoggable(PlatformLogger.FINE)) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1323
                // Verify listeningBoundsChildren is correct
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1324
                int sum = 0;
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1325
                for (Component comp : component) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1326
                    sum += comp.numListening(mask);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1327
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1328
                if (listeningBoundsChildren != sum) {
3938
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
  1329
                    eventLog.fine("Assertion (listeningBoundsChildren == sum) failed");
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1330
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1331
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1332
            return listeningBoundsChildren + superListening;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1333
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1334
            // assert false;
3938
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
  1335
            if (eventLog.isLoggable(PlatformLogger.FINE)) {
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
  1336
                eventLog.fine("This code must never be reached");
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1337
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1338
            return superListening;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1339
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1340
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1341
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1342
    // Should only be called while holding tree lock
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1343
    void adjustListeningChildren(long mask, int num) {
3938
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
  1344
        if (eventLog.isLoggable(PlatformLogger.FINE)) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1345
            boolean toAssert = (mask == AWTEvent.HIERARCHY_EVENT_MASK ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1346
                                mask == AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1347
                                mask == (AWTEvent.HIERARCHY_EVENT_MASK |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1348
                                         AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1349
            if (!toAssert) {
3938
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
  1350
                eventLog.fine("Assertion failed");
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1351
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1352
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1353
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1354
        if (num == 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1355
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1356
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1357
        if ((mask & AWTEvent.HIERARCHY_EVENT_MASK) != 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1358
            listeningChildren += num;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1359
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1360
        if ((mask & AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK) != 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1361
            listeningBoundsChildren += num;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1362
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1363
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1364
        adjustListeningChildrenOnParent(mask, num);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1365
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1366
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1367
    // Should only be called while holding tree lock
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1368
    void adjustDescendants(int num) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1369
        if (num == 0)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1370
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1371
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1372
        descendantsCount += num;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1373
        adjustDecendantsOnParent(num);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1374
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1375
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1376
    // Should only be called while holding tree lock
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1377
    void adjustDecendantsOnParent(int num) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1378
        if (parent != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1379
            parent.adjustDescendants(num);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1380
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1381
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1382
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1383
    // Should only be called while holding tree lock
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1384
    int countHierarchyMembers() {
3938
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
  1385
        if (log.isLoggable(PlatformLogger.FINE)) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1386
            // Verify descendantsCount is correct
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1387
            int sum = 0;
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1388
            for (Component comp : component) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1389
                sum += comp.countHierarchyMembers();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1390
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1391
            if (descendantsCount != sum) {
3938
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
  1392
                log.fine("Assertion (descendantsCount == sum) failed");
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1393
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1394
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1395
        return descendantsCount + 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1396
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1397
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1398
    private int getListenersCount(int id, boolean enabledOnToolkit) {
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  1399
        checkTreeLock();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1400
        if (enabledOnToolkit) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1401
            return descendantsCount;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1402
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1403
        switch (id) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1404
          case HierarchyEvent.HIERARCHY_CHANGED:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1405
            return listeningChildren;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1406
          case HierarchyEvent.ANCESTOR_MOVED:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1407
          case HierarchyEvent.ANCESTOR_RESIZED:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1408
            return listeningBoundsChildren;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1409
          default:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1410
            return 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1411
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1412
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1413
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1414
    final int createHierarchyEvents(int id, Component changed,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1415
        Container changedParent, long changeFlags, boolean enabledOnToolkit)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1416
    {
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  1417
        checkTreeLock();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1418
        int listeners = getListenersCount(id, enabledOnToolkit);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1419
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1420
        for (int count = listeners, i = 0; count > 0; i++) {
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1421
            count -= component.get(i).createHierarchyEvents(id, changed,
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1422
                changedParent, changeFlags, enabledOnToolkit);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1423
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1424
        return listeners +
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1425
            super.createHierarchyEvents(id, changed, changedParent,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1426
                                        changeFlags, enabledOnToolkit);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1427
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1428
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1429
    final void createChildHierarchyEvents(int id, long changeFlags,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1430
        boolean enabledOnToolkit)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1431
    {
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  1432
        checkTreeLock();
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1433
        if (component.isEmpty()) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1434
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1435
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1436
        int listeners = getListenersCount(id, enabledOnToolkit);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1437
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1438
        for (int count = listeners, i = 0; count > 0; i++) {
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1439
            count -= component.get(i).createHierarchyEvents(id, this, parent,
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1440
                changeFlags, enabledOnToolkit);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1441
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1442
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1443
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1444
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1445
     * Gets the layout manager for this container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1446
     * @see #doLayout
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1447
     * @see #setLayout
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1448
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1449
    public LayoutManager getLayout() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1450
        return layoutMgr;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1451
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1452
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1453
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1454
     * Sets the layout manager for this container.
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1455
     * <p>
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1456
     * This method changes layout-related information, and therefore,
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1457
     * invalidates the component hierarchy.
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1458
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1459
     * @param mgr the specified layout manager
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1460
     * @see #doLayout
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1461
     * @see #getLayout
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1462
     * @see #invalidate
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1463
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1464
    public void setLayout(LayoutManager mgr) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1465
        layoutMgr = mgr;
1183
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  1466
        invalidateIfValid();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1467
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1468
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1469
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1470
     * Causes this container to lay out its components.  Most programs
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1471
     * should not call this method directly, but should invoke
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1472
     * the <code>validate</code> method instead.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1473
     * @see LayoutManager#layoutContainer
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1474
     * @see #setLayout
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1475
     * @see #validate
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1476
     * @since JDK1.1
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1477
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1478
    public void doLayout() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1479
        layout();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1480
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1481
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1482
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1483
     * @deprecated As of JDK version 1.1,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1484
     * replaced by <code>doLayout()</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1485
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1486
    @Deprecated
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1487
    public void layout() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1488
        LayoutManager layoutMgr = this.layoutMgr;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1489
        if (layoutMgr != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1490
            layoutMgr.layoutContainer(this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1491
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1492
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1493
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1494
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1495
     * Invalidates the container.  The container and all parents
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1496
     * above it are marked as needing to be laid out.  This method can
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1497
     * be called often, so it needs to execute quickly.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1498
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1499
     * <p> If the {@code LayoutManager} installed on this container is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1500
     * an instance of {@code LayoutManager2}, then
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1501
     * {@link LayoutManager2#invalidateLayout(Container)} is invoked on
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1502
     * it supplying this {@code Container} as the argument.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1503
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1504
     * @see #validate
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1505
     * @see #layout
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1506
     * @see LayoutManager
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1507
     * @see LayoutManager2#invalidateLayout(Container)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1508
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1509
    public void invalidate() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1510
        LayoutManager layoutMgr = this.layoutMgr;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1511
        if (layoutMgr instanceof LayoutManager2) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1512
            LayoutManager2 lm = (LayoutManager2) layoutMgr;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1513
            lm.invalidateLayout(this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1514
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1515
        super.invalidate();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1516
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1517
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1518
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1519
     * Validates this container and all of its subcomponents.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1520
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1521
     * The <code>validate</code> method is used to cause a container
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1522
     * to lay out its subcomponents again. It should be invoked when
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1523
     * this container's subcomponents are modified (added to or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1524
     * removed from the container, or layout-related information
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1525
     * changed) after the container has been displayed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1526
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1527
     * <p>If this {@code Container} is not valid, this method invokes
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1528
     * the {@code validateTree} method and marks this {@code Container}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1529
     * as valid. Otherwise, no action is performed.
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1530
     * <p>
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1531
     * Note that the {@code invalidate()} method may invalidate not only the
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1532
     * component it is called upon, but also the parents of the component.
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1533
     * Therefore, to restore the validity of the hierarchy, the {@code
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1534
     * validate()} method must be invoked on the top-most invalid container of
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1535
     * the hierarchy. For performance reasons a developer may postpone the
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1536
     * validation of the hierarchy till a bunch of layout-related operations
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1537
     * completes, e.g. after adding all the children to the container.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1538
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1539
     * @see #add(java.awt.Component)
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1540
     * @see #invalidate
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1541
     * @see javax.swing.JComponent#revalidate()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1542
     * @see #validateTree
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1543
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1544
    public void validate() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1545
        /* Avoid grabbing lock unless really necessary. */
1183
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  1546
        if (!isValid()) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1547
            boolean updateCur = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1548
            synchronized (getTreeLock()) {
1183
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  1549
                if (!isValid() && peer != null) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1550
                    ContainerPeer p = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1551
                    if (peer instanceof ContainerPeer) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1552
                        p = (ContainerPeer) peer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1553
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1554
                    if (p != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1555
                        p.beginValidate();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1556
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1557
                    validateTree();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1558
                    if (p != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1559
                        p.endValidate();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1560
                        updateCur = isVisible();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1561
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1562
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1563
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1564
            if (updateCur) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1565
                updateCursorImmediately();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1566
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1567
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1568
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1569
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1570
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1571
     * Recursively descends the container tree and recomputes the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1572
     * layout for any subtrees marked as needing it (those marked as
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1573
     * invalid).  Synchronization should be provided by the method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1574
     * that calls this one:  <code>validate</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1575
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1576
     * @see #doLayout
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1577
     * @see #validate
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1578
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1579
    protected void validateTree() {
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  1580
        checkTreeLock();
1183
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  1581
        if (!isValid()) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1582
            if (peer instanceof ContainerPeer) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1583
                ((ContainerPeer)peer).beginLayout();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1584
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1585
            doLayout();
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1586
            for (int i = 0; i < component.size(); i++) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1587
                Component comp = component.get(i);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1588
                if (   (comp instanceof Container)
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1589
                       && !(comp instanceof Window)
1183
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  1590
                       && !comp.isValid()) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1591
                    ((Container)comp).validateTree();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1592
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1593
                    comp.validate();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1594
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1595
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1596
            if (peer instanceof ContainerPeer) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1597
                ((ContainerPeer)peer).endLayout();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1598
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1599
        }
1183
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  1600
        super.validate();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1601
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1602
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1603
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1604
     * Recursively descends the container tree and invalidates all
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1605
     * contained components.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1606
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1607
    void invalidateTree() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1608
        synchronized (getTreeLock()) {
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1609
            for (int i = 0; i < component.size(); i++) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  1610
                Component comp = component.get(i);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1611
                if (comp instanceof Container) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1612
                    ((Container)comp).invalidateTree();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1613
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1614
                else {
1183
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  1615
                    comp.invalidateIfValid();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1616
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1617
            }
1183
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  1618
            invalidateIfValid();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1619
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1620
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1621
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1622
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1623
     * Sets the font of this container.
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1624
     * <p>
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1625
     * This method changes layout-related information, and therefore,
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1626
     * invalidates the component hierarchy.
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1627
     *
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1628
     * @param f The font to become this container's font.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1629
     * @see Component#getFont
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  1630
     * @see #invalidate
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1631
     * @since JDK1.0
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1632
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1633
    public void setFont(Font f) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1634
        boolean shouldinvalidate = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1635
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1636
        Font oldfont = getFont();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1637
        super.setFont(f);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1638
        Font newfont = getFont();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1639
        if (newfont != oldfont && (oldfont == null ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1640
                                   !oldfont.equals(newfont))) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1641
            invalidateTree();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1642
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1643
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1644
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1645
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1646
     * Returns the preferred size of this container.  If the preferred size has
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1647
     * not been set explicitly by {@link Component#setPreferredSize(Dimension)}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1648
     * and this {@code Container} has a {@code non-null} {@link LayoutManager},
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1649
     * then {@link LayoutManager#preferredLayoutSize(Container)}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1650
     * is used to calculate the preferred size.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1651
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1652
     * <p>Note: some implementations may cache the value returned from the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1653
     * {@code LayoutManager}.  Implementations that cache need not invoke
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1654
     * {@code preferredLayoutSize} on the {@code LayoutManager} every time
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1655
     * this method is invoked, rather the {@code LayoutManager} will only
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1656
     * be queried after the {@code Container} becomes invalid.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1657
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1658
     * @return    an instance of <code>Dimension</code> that represents
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1659
     *                the preferred size of this container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1660
     * @see       #getMinimumSize
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1661
     * @see       #getMaximumSize
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1662
     * @see       #getLayout
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1663
     * @see       LayoutManager#preferredLayoutSize(Container)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1664
     * @see       Component#getPreferredSize
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1665
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1666
    public Dimension getPreferredSize() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1667
        return preferredSize();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1668
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1669
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1670
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1671
     * @deprecated As of JDK version 1.1,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1672
     * replaced by <code>getPreferredSize()</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1673
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1674
    @Deprecated
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1675
    public Dimension preferredSize() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1676
        /* Avoid grabbing the lock if a reasonable cached size value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1677
         * is available.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1678
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1679
        Dimension dim = prefSize;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1680
        if (dim == null || !(isPreferredSizeSet() || isValid())) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1681
            synchronized (getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1682
                prefSize = (layoutMgr != null) ?
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1683
                    layoutMgr.preferredLayoutSize(this) :
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1684
                    super.preferredSize();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1685
                dim = prefSize;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1686
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1687
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1688
        if (dim != null){
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1689
            return new Dimension(dim);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1690
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1691
        else{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1692
            return dim;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1693
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1694
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1695
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1696
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1697
     * Returns the minimum size of this container.  If the minimum size has
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1698
     * not been set explicitly by {@link Component#setMinimumSize(Dimension)}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1699
     * and this {@code Container} has a {@code non-null} {@link LayoutManager},
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1700
     * then {@link LayoutManager#minimumLayoutSize(Container)}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1701
     * is used to calculate the minimum size.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1702
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1703
     * <p>Note: some implementations may cache the value returned from the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1704
     * {@code LayoutManager}.  Implementations that cache need not invoke
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1705
     * {@code minimumLayoutSize} on the {@code LayoutManager} every time
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1706
     * this method is invoked, rather the {@code LayoutManager} will only
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1707
     * be queried after the {@code Container} becomes invalid.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1708
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1709
     * @return    an instance of <code>Dimension</code> that represents
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1710
     *                the minimum size of this container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1711
     * @see       #getPreferredSize
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1712
     * @see       #getMaximumSize
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1713
     * @see       #getLayout
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1714
     * @see       LayoutManager#minimumLayoutSize(Container)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1715
     * @see       Component#getMinimumSize
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1716
     * @since     JDK1.1
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1717
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1718
    public Dimension getMinimumSize() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1719
        return minimumSize();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1720
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1721
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1722
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1723
     * @deprecated As of JDK version 1.1,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1724
     * replaced by <code>getMinimumSize()</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1725
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1726
    @Deprecated
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1727
    public Dimension minimumSize() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1728
        /* Avoid grabbing the lock if a reasonable cached size value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1729
         * is available.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1730
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1731
        Dimension dim = minSize;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1732
        if (dim == null || !(isMinimumSizeSet() || isValid())) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1733
            synchronized (getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1734
                minSize = (layoutMgr != null) ?
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1735
                    layoutMgr.minimumLayoutSize(this) :
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1736
                    super.minimumSize();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1737
                dim = minSize;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1738
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1739
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1740
        if (dim != null){
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1741
            return new Dimension(dim);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1742
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1743
        else{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1744
            return dim;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1745
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1746
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1747
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1748
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1749
     * Returns the maximum size of this container.  If the maximum size has
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1750
     * not been set explicitly by {@link Component#setMaximumSize(Dimension)}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1751
     * and the {@link LayoutManager} installed on this {@code Container}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1752
     * is an instance of {@link LayoutManager2}, then
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1753
     * {@link LayoutManager2#maximumLayoutSize(Container)}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1754
     * is used to calculate the maximum size.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1755
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1756
     * <p>Note: some implementations may cache the value returned from the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1757
     * {@code LayoutManager2}.  Implementations that cache need not invoke
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1758
     * {@code maximumLayoutSize} on the {@code LayoutManager2} every time
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1759
     * this method is invoked, rather the {@code LayoutManager2} will only
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1760
     * be queried after the {@code Container} becomes invalid.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1761
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1762
     * @return    an instance of <code>Dimension</code> that represents
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1763
     *                the maximum size of this container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1764
     * @see       #getPreferredSize
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1765
     * @see       #getMinimumSize
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1766
     * @see       #getLayout
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1767
     * @see       LayoutManager2#maximumLayoutSize(Container)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1768
     * @see       Component#getMaximumSize
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1769
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1770
    public Dimension getMaximumSize() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1771
        /* Avoid grabbing the lock if a reasonable cached size value
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1772
         * is available.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1773
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1774
        Dimension dim = maxSize;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1775
        if (dim == null || !(isMaximumSizeSet() || isValid())) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1776
            synchronized (getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1777
               if (layoutMgr instanceof LayoutManager2) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1778
                    LayoutManager2 lm = (LayoutManager2) layoutMgr;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1779
                    maxSize = lm.maximumLayoutSize(this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1780
               } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1781
                    maxSize = super.getMaximumSize();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1782
               }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1783
               dim = maxSize;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1784
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1785
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1786
        if (dim != null){
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1787
            return new Dimension(dim);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1788
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1789
        else{
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1790
            return dim;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1791
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1792
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1793
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1794
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1795
     * Returns the alignment along the x axis.  This specifies how
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1796
     * the component would like to be aligned relative to other
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1797
     * components.  The value should be a number between 0 and 1
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1798
     * where 0 represents alignment along the origin, 1 is aligned
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1799
     * the furthest away from the origin, 0.5 is centered, etc.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1800
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1801
    public float getAlignmentX() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1802
        float xAlign;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1803
        if (layoutMgr instanceof LayoutManager2) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1804
            synchronized (getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1805
                LayoutManager2 lm = (LayoutManager2) layoutMgr;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1806
                xAlign = lm.getLayoutAlignmentX(this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1807
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1808
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1809
            xAlign = super.getAlignmentX();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1810
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1811
        return xAlign;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1812
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1813
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1814
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1815
     * Returns the alignment along the y axis.  This specifies how
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1816
     * the component would like to be aligned relative to other
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1817
     * components.  The value should be a number between 0 and 1
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1818
     * where 0 represents alignment along the origin, 1 is aligned
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1819
     * the furthest away from the origin, 0.5 is centered, etc.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1820
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1821
    public float getAlignmentY() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1822
        float yAlign;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1823
        if (layoutMgr instanceof LayoutManager2) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1824
            synchronized (getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1825
                LayoutManager2 lm = (LayoutManager2) layoutMgr;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1826
                yAlign = lm.getLayoutAlignmentY(this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1827
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1828
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1829
            yAlign = super.getAlignmentY();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1830
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1831
        return yAlign;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1832
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1833
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1834
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1835
     * Paints the container. This forwards the paint to any lightweight
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1836
     * components that are children of this container. If this method is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1837
     * reimplemented, super.paint(g) should be called so that lightweight
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1838
     * components are properly rendered. If a child component is entirely
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1839
     * clipped by the current clipping setting in g, paint() will not be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1840
     * forwarded to that child.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1841
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1842
     * @param g the specified Graphics window
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1843
     * @see   Component#update(Graphics)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1844
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1845
    public void paint(Graphics g) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1846
        if (isShowing()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1847
            synchronized (this) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1848
                if (printing) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1849
                    if (printingThreads.contains(Thread.currentThread())) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1850
                        return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1851
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1852
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1853
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1854
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1855
            // The container is showing on screen and
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1856
            // this paint() is not called from print().
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1857
            // Paint self and forward the paint to lightweight subcomponents.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1858
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1859
            // super.paint(); -- Don't bother, since it's a NOP.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1860
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1861
            GraphicsCallback.PaintCallback.getInstance().
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  1862
                runComponents(getComponentsSync(), g, GraphicsCallback.LIGHTWEIGHTS);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1863
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1864
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1865
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1866
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1867
     * Updates the container.  This forwards the update to any lightweight
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1868
     * components that are children of this container.  If this method is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1869
     * reimplemented, super.update(g) should be called so that lightweight
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1870
     * components are properly rendered.  If a child component is entirely
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1871
     * clipped by the current clipping setting in g, update() will not be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1872
     * forwarded to that child.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1873
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1874
     * @param g the specified Graphics window
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1875
     * @see   Component#update(Graphics)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1876
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1877
    public void update(Graphics g) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1878
        if (isShowing()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1879
            if (! (peer instanceof LightweightPeer)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1880
                g.clearRect(0, 0, width, height);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1881
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1882
            paint(g);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1883
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1884
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1885
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1886
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1887
     * Prints the container. This forwards the print to any lightweight
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1888
     * components that are children of this container. If this method is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1889
     * reimplemented, super.print(g) should be called so that lightweight
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1890
     * components are properly rendered. If a child component is entirely
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1891
     * clipped by the current clipping setting in g, print() will not be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1892
     * forwarded to that child.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1893
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1894
     * @param g the specified Graphics window
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1895
     * @see   Component#update(Graphics)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1896
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1897
    public void print(Graphics g) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1898
        if (isShowing()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1899
            Thread t = Thread.currentThread();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1900
            try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1901
                synchronized (this) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1902
                    if (printingThreads == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1903
                        printingThreads = new HashSet();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1904
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1905
                    printingThreads.add(t);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1906
                    printing = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1907
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1908
                super.print(g);  // By default, Component.print() calls paint()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1909
            } finally {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1910
                synchronized (this) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1911
                    printingThreads.remove(t);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1912
                    printing = !printingThreads.isEmpty();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1913
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1914
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1915
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1916
            GraphicsCallback.PrintCallback.getInstance().
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  1917
                runComponents(getComponentsSync(), g, GraphicsCallback.LIGHTWEIGHTS);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1918
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1919
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1920
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1921
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1922
     * Paints each of the components in this container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1923
     * @param     g   the graphics context.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1924
     * @see       Component#paint
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1925
     * @see       Component#paintAll
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1926
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1927
    public void paintComponents(Graphics g) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1928
        if (isShowing()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1929
            GraphicsCallback.PaintAllCallback.getInstance().
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  1930
                runComponents(getComponentsSync(), g, GraphicsCallback.TWO_PASSES);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1931
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1932
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1933
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1934
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1935
     * Simulates the peer callbacks into java.awt for printing of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1936
     * lightweight Containers.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1937
     * @param     g   the graphics context to use for printing.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1938
     * @see       Component#printAll
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1939
     * @see       #printComponents
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1940
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1941
    void lightweightPaint(Graphics g) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1942
        super.lightweightPaint(g);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1943
        paintHeavyweightComponents(g);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1944
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1945
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1946
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1947
     * Prints all the heavyweight subcomponents.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1948
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1949
    void paintHeavyweightComponents(Graphics g) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1950
        if (isShowing()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1951
            GraphicsCallback.PaintHeavyweightComponentsCallback.getInstance().
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  1952
                runComponents(getComponentsSync(), g,
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  1953
                              GraphicsCallback.LIGHTWEIGHTS | GraphicsCallback.HEAVYWEIGHTS);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1954
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1955
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1956
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1957
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1958
     * Prints each of the components in this container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1959
     * @param     g   the graphics context.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1960
     * @see       Component#print
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1961
     * @see       Component#printAll
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1962
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1963
    public void printComponents(Graphics g) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1964
        if (isShowing()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1965
            GraphicsCallback.PrintAllCallback.getInstance().
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  1966
                runComponents(getComponentsSync(), g, GraphicsCallback.TWO_PASSES);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1967
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1968
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1969
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1970
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1971
     * Simulates the peer callbacks into java.awt for printing of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1972
     * lightweight Containers.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1973
     * @param     g   the graphics context to use for printing.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1974
     * @see       Component#printAll
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1975
     * @see       #printComponents
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1976
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1977
    void lightweightPrint(Graphics g) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1978
        super.lightweightPrint(g);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1979
        printHeavyweightComponents(g);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1980
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1981
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1982
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1983
     * Prints all the heavyweight subcomponents.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1984
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1985
    void printHeavyweightComponents(Graphics g) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1986
        if (isShowing()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1987
            GraphicsCallback.PrintHeavyweightComponentsCallback.getInstance().
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  1988
                runComponents(getComponentsSync(), g,
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  1989
                              GraphicsCallback.LIGHTWEIGHTS | GraphicsCallback.HEAVYWEIGHTS);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1990
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1991
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1992
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1993
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1994
     * Adds the specified container listener to receive container events
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1995
     * from this container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1996
     * If l is null, no exception is thrown and no action is performed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1997
     * <p>Refer to <a href="doc-files/AWTThreadIssues.html#ListenersThreads"
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1998
     * >AWT Threading Issues</a> for details on AWT's threading model.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  1999
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2000
     * @param    l the container listener
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2001
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2002
     * @see #removeContainerListener
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2003
     * @see #getContainerListeners
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2004
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2005
    public synchronized void addContainerListener(ContainerListener l) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2006
        if (l == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2007
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2008
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2009
        containerListener = AWTEventMulticaster.add(containerListener, l);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2010
        newEventsOnly = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2011
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2012
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2013
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2014
     * Removes the specified container listener so it no longer receives
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2015
     * container events from this container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2016
     * If l is null, no exception is thrown and no action is performed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2017
     * <p>Refer to <a href="doc-files/AWTThreadIssues.html#ListenersThreads"
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2018
     * >AWT Threading Issues</a> for details on AWT's threading model.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2019
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2020
     * @param   l the container listener
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2021
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2022
     * @see #addContainerListener
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2023
     * @see #getContainerListeners
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2024
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2025
    public synchronized void removeContainerListener(ContainerListener l) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2026
        if (l == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2027
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2028
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2029
        containerListener = AWTEventMulticaster.remove(containerListener, l);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2030
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2031
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2032
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2033
     * Returns an array of all the container listeners
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2034
     * registered on this container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2035
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2036
     * @return all of this container's <code>ContainerListener</code>s
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2037
     *         or an empty array if no container
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2038
     *         listeners are currently registered
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2039
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2040
     * @see #addContainerListener
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2041
     * @see #removeContainerListener
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2042
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2043
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2044
    public synchronized ContainerListener[] getContainerListeners() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2045
        return (ContainerListener[]) (getListeners(ContainerListener.class));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2046
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2047
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2048
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2049
     * Returns an array of all the objects currently registered
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2050
     * as <code><em>Foo</em>Listener</code>s
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2051
     * upon this <code>Container</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2052
     * <code><em>Foo</em>Listener</code>s are registered using the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2053
     * <code>add<em>Foo</em>Listener</code> method.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2054
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2055
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2056
     * You can specify the <code>listenerType</code> argument
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2057
     * with a class literal, such as
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2058
     * <code><em>Foo</em>Listener.class</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2059
     * For example, you can query a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2060
     * <code>Container</code> <code>c</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2061
     * for its container listeners with the following code:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2062
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2063
     * <pre>ContainerListener[] cls = (ContainerListener[])(c.getListeners(ContainerListener.class));</pre>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2064
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2065
     * If no such listeners exist, this method returns an empty array.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2066
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2067
     * @param listenerType the type of listeners requested; this parameter
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2068
     *          should specify an interface that descends from
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2069
     *          <code>java.util.EventListener</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2070
     * @return an array of all objects registered as
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2071
     *          <code><em>Foo</em>Listener</code>s on this container,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2072
     *          or an empty array if no such listeners have been added
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2073
     * @exception ClassCastException if <code>listenerType</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2074
     *          doesn't specify a class or interface that implements
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2075
     *          <code>java.util.EventListener</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2076
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2077
     * @see #getContainerListeners
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2078
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2079
     * @since 1.3
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2080
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2081
    public <T extends EventListener> T[] getListeners(Class<T> listenerType) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2082
        EventListener l = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2083
        if  (listenerType == ContainerListener.class) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2084
            l = containerListener;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2085
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2086
            return super.getListeners(listenerType);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2087
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2088
        return AWTEventMulticaster.getListeners(l, listenerType);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2089
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2090
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2091
    // REMIND: remove when filtering is done at lower level
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2092
    boolean eventEnabled(AWTEvent e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2093
        int id = e.getID();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2094
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2095
        if (id == ContainerEvent.COMPONENT_ADDED ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2096
            id == ContainerEvent.COMPONENT_REMOVED) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2097
            if ((eventMask & AWTEvent.CONTAINER_EVENT_MASK) != 0 ||
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2098
                containerListener != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2099
                return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2100
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2101
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2102
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2103
        return super.eventEnabled(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2104
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2105
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2106
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2107
     * Processes events on this container. If the event is a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2108
     * <code>ContainerEvent</code>, it invokes the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2109
     * <code>processContainerEvent</code> method, else it invokes
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2110
     * its superclass's <code>processEvent</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2111
     * <p>Note that if the event parameter is <code>null</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2112
     * the behavior is unspecified and may result in an
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2113
     * exception.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2114
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2115
     * @param e the event
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2116
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2117
    protected void processEvent(AWTEvent e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2118
        if (e instanceof ContainerEvent) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2119
            processContainerEvent((ContainerEvent)e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2120
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2121
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2122
        super.processEvent(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2123
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2124
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2125
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2126
     * Processes container events occurring on this container by
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2127
     * dispatching them to any registered ContainerListener objects.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2128
     * NOTE: This method will not be called unless container events
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2129
     * are enabled for this component; this happens when one of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2130
     * following occurs:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2131
     * <ul>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2132
     * <li>A ContainerListener object is registered via
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2133
     *     <code>addContainerListener</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2134
     * <li>Container events are enabled via <code>enableEvents</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2135
     * </ul>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2136
     * <p>Note that if the event parameter is <code>null</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2137
     * the behavior is unspecified and may result in an
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2138
     * exception.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2139
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2140
     * @param e the container event
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2141
     * @see Component#enableEvents
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2142
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2143
    protected void processContainerEvent(ContainerEvent e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2144
        ContainerListener listener = containerListener;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2145
        if (listener != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2146
            switch(e.getID()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2147
              case ContainerEvent.COMPONENT_ADDED:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2148
                listener.componentAdded(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2149
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2150
              case ContainerEvent.COMPONENT_REMOVED:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2151
                listener.componentRemoved(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2152
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2153
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2154
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2155
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2156
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2157
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2158
     * Dispatches an event to this component or one of its sub components.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2159
     * Create ANCESTOR_RESIZED and ANCESTOR_MOVED events in response to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2160
     * COMPONENT_RESIZED and COMPONENT_MOVED events. We have to do this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2161
     * here instead of in processComponentEvent because ComponentEvents
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2162
     * may not be enabled for this Container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2163
     * @param e the event
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2164
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2165
    void dispatchEventImpl(AWTEvent e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2166
        if ((dispatcher != null) && dispatcher.dispatchEvent(e)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2167
            // event was sent to a lightweight component.  The
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2168
            // native-produced event sent to the native container
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2169
            // must be properly disposed of by the peer, so it
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2170
            // gets forwarded.  If the native host has been removed
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2171
            // as a result of the sending the lightweight event,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2172
            // the peer reference will be null.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2173
            e.consume();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2174
            if (peer != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2175
                peer.handleEvent(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2176
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2177
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2178
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2179
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2180
        super.dispatchEventImpl(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2181
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2182
        synchronized (getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2183
            switch (e.getID()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2184
              case ComponentEvent.COMPONENT_RESIZED:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2185
                createChildHierarchyEvents(HierarchyEvent.ANCESTOR_RESIZED, 0,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2186
                                           Toolkit.enabledOnToolkit(AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2187
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2188
              case ComponentEvent.COMPONENT_MOVED:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2189
                createChildHierarchyEvents(HierarchyEvent.ANCESTOR_MOVED, 0,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2190
                                       Toolkit.enabledOnToolkit(AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2191
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2192
              default:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2193
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2194
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2195
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2196
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2197
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2198
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2199
     * Dispatches an event to this component, without trying to forward
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2200
     * it to any subcomponents
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2201
     * @param e the event
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2202
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2203
    void dispatchEventToSelf(AWTEvent e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2204
        super.dispatchEventImpl(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2205
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2206
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2207
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2208
     * Fetchs the top-most (deepest) lightweight component that is interested
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2209
     * in receiving mouse events.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2210
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2211
    Component getMouseEventTarget(int x, int y, boolean includeSelf) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2212
        return getMouseEventTarget(x, y, includeSelf,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2213
                                   MouseEventTargetFilter.FILTER,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2214
                                   !SEARCH_HEAVYWEIGHTS);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2215
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2216
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2217
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2218
     * Fetches the top-most (deepest) component to receive SunDropTargetEvents.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2219
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2220
    Component getDropTargetEventTarget(int x, int y, boolean includeSelf) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2221
        return getMouseEventTarget(x, y, includeSelf,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2222
                                   DropTargetEventTargetFilter.FILTER,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2223
                                   SEARCH_HEAVYWEIGHTS);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2224
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2225
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2226
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2227
     * A private version of getMouseEventTarget which has two additional
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2228
     * controllable behaviors. This method searches for the top-most
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2229
     * descendant of this container that contains the given coordinates
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2230
     * and is accepted by the given filter. The search will be constrained to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2231
     * lightweight descendants if the last argument is <code>false</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2232
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2233
     * @param filter EventTargetFilter instance to determine whether the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2234
     *        given component is a valid target for this event.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2235
     * @param searchHeavyweights if <code>false</code>, the method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2236
     *        will bypass heavyweight components during the search.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2237
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2238
    private Component getMouseEventTarget(int x, int y, boolean includeSelf,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2239
                                          EventTargetFilter filter,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2240
                                          boolean searchHeavyweights) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2241
        Component comp = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2242
        if (searchHeavyweights) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2243
            comp = getMouseEventTargetImpl(x, y, includeSelf, filter,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2244
                                           SEARCH_HEAVYWEIGHTS,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2245
                                           searchHeavyweights);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2246
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2247
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2248
        if (comp == null || comp == this) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2249
            comp = getMouseEventTargetImpl(x, y, includeSelf, filter,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2250
                                           !SEARCH_HEAVYWEIGHTS,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2251
                                           searchHeavyweights);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2252
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2253
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2254
        return comp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2255
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2256
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2257
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2258
     * A private version of getMouseEventTarget which has three additional
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2259
     * controllable behaviors. This method searches for the top-most
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2260
     * descendant of this container that contains the given coordinates
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2261
     * and is accepted by the given filter. The search will be constrained to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2262
     * descendants of only lightweight children or only heavyweight children
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2263
     * of this container depending on searchHeavyweightChildren. The search will
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2264
     * be constrained to only lightweight descendants of the searched children
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2265
     * of this container if searchHeavyweightDescendants is <code>false</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2266
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2267
     * @param filter EventTargetFilter instance to determine whether the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2268
     *        selected component is a valid target for this event.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2269
     * @param searchHeavyweightChildren if <code>true</code>, the method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2270
     *        will bypass immediate lightweight children during the search.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2271
     *        If <code>false</code>, the methods will bypass immediate
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2272
     *        heavyweight children during the search.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2273
     * @param searchHeavyweightDescendants if <code>false</code>, the method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2274
     *        will bypass heavyweight descendants which are not immediate
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2275
     *        children during the search. If <code>true</code>, the method
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2276
     *        will traverse both lightweight and heavyweight descendants during
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2277
     *        the search.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2278
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2279
    private Component getMouseEventTargetImpl(int x, int y, boolean includeSelf,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2280
                                         EventTargetFilter filter,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2281
                                         boolean searchHeavyweightChildren,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2282
                                         boolean searchHeavyweightDescendants) {
125
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2283
        synchronized (getTreeLock()) {
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2284
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2285
            for (int i = 0; i < component.size(); i++) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2286
                Component comp = component.get(i);
125
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2287
                if (comp != null && comp.visible &&
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2288
                    ((!searchHeavyweightChildren &&
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2289
                      comp.peer instanceof LightweightPeer) ||
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2290
                     (searchHeavyweightChildren &&
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2291
                      !(comp.peer instanceof LightweightPeer))) &&
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2292
                    comp.contains(x - comp.x, y - comp.y)) {
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2293
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2294
                    // found a component that intersects the point, see if there
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2295
                    // is a deeper possibility.
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2296
                    if (comp instanceof Container) {
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2297
                        Container child = (Container) comp;
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2298
                        Component deeper = child.getMouseEventTarget(
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2299
                                x - child.x,
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2300
                                y - child.y,
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2301
                                includeSelf,
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2302
                                filter,
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2303
                                searchHeavyweightDescendants);
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2304
                        if (deeper != null) {
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2305
                            return deeper;
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2306
                        }
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2307
                    } else {
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2308
                        if (filter.accept(comp)) {
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2309
                            // there isn't a deeper target, but this component
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2310
                            // is a target
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2311
                            return comp;
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2312
                        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2313
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2314
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2315
            }
125
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2316
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2317
            boolean isPeerOK;
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2318
            boolean isMouseOverMe;
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2319
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2320
            isPeerOK = (peer instanceof LightweightPeer) || includeSelf;
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2321
            isMouseOverMe = contains(x,y);
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2322
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2323
            // didn't find a child target, return this component if it's
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2324
            // a possible target
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2325
            if (isMouseOverMe && isPeerOK && filter.accept(this)) {
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2326
                return this;
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2327
            }
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2328
            // no possible target
079ae88eaea9 6607660: java.awt.Container.getMouseEventTargetImpl should be invoked while holding the TreeLock
anthony
parents: 121
diff changeset
  2329
            return null;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2330
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2331
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2332
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2333
    static interface EventTargetFilter {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2334
        boolean accept(final Component comp);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2335
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2336
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2337
    static class MouseEventTargetFilter implements EventTargetFilter {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2338
        static final EventTargetFilter FILTER = new MouseEventTargetFilter();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2339
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2340
        private MouseEventTargetFilter() {}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2341
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2342
        public boolean accept(final Component comp) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2343
            return (comp.eventMask & AWTEvent.MOUSE_MOTION_EVENT_MASK) != 0
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2344
                || (comp.eventMask & AWTEvent.MOUSE_EVENT_MASK) != 0
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2345
                || (comp.eventMask & AWTEvent.MOUSE_WHEEL_EVENT_MASK) != 0
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2346
                || comp.mouseListener != null
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2347
                || comp.mouseMotionListener != null
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2348
                || comp.mouseWheelListener != null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2349
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2350
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2351
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2352
    static class DropTargetEventTargetFilter implements EventTargetFilter {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2353
        static final EventTargetFilter FILTER = new DropTargetEventTargetFilter();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2354
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2355
        private DropTargetEventTargetFilter() {}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2356
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2357
        public boolean accept(final Component comp) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2358
            DropTarget dt = comp.getDropTarget();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2359
            return dt != null && dt.isActive();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2360
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2361
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2362
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2363
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2364
     * This is called by lightweight components that want the containing
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2365
     * windowed parent to enable some kind of events on their behalf.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2366
     * This is needed for events that are normally only dispatched to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2367
     * windows to be accepted so that they can be forwarded downward to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2368
     * the lightweight component that has enabled them.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2369
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2370
    void proxyEnableEvents(long events) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2371
        if (peer instanceof LightweightPeer) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2372
            // this container is lightweight.... continue sending it
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2373
            // upward.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2374
            if (parent != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2375
                parent.proxyEnableEvents(events);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2376
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2377
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2378
            // This is a native container, so it needs to host
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2379
            // one of it's children.  If this function is called before
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2380
            // a peer has been created we don't yet have a dispatcher
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2381
            // because it has not yet been determined if this instance
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2382
            // is lightweight.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2383
            if (dispatcher != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2384
                dispatcher.enableEvents(events);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2385
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2386
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2387
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2388
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2389
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2390
     * @deprecated As of JDK version 1.1,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2391
     * replaced by <code>dispatchEvent(AWTEvent e)</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2392
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2393
    @Deprecated
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2394
    public void deliverEvent(Event e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2395
        Component comp = getComponentAt(e.x, e.y);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2396
        if ((comp != null) && (comp != this)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2397
            e.translate(-comp.x, -comp.y);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2398
            comp.deliverEvent(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2399
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2400
            postEvent(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2401
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2402
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2403
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2404
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2405
     * Locates the component that contains the x,y position.  The
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2406
     * top-most child component is returned in the case where there
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2407
     * is overlap in the components.  This is determined by finding
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2408
     * the component closest to the index 0 that claims to contain
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2409
     * the given point via Component.contains(), except that Components
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2410
     * which have native peers take precedence over those which do not
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2411
     * (i.e., lightweight Components).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2412
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2413
     * @param x the <i>x</i> coordinate
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2414
     * @param y the <i>y</i> coordinate
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2415
     * @return null if the component does not contain the position.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2416
     * If there is no child component at the requested point and the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2417
     * point is within the bounds of the container the container itself
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2418
     * is returned; otherwise the top-most child is returned.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2419
     * @see Component#contains
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2420
     * @since JDK1.1
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2421
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2422
    public Component getComponentAt(int x, int y) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2423
        return locate(x, y);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2424
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2425
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2426
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2427
     * @deprecated As of JDK version 1.1,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2428
     * replaced by <code>getComponentAt(int, int)</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2429
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2430
    @Deprecated
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2431
    public Component locate(int x, int y) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2432
        if (!contains(x, y)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2433
            return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2434
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2435
        synchronized (getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2436
            // Two passes: see comment in sun.awt.SunGraphicsCallback
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2437
            for (int i = 0; i < component.size(); i++) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2438
                Component comp = component.get(i);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2439
                if (comp != null &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2440
                    !(comp.peer instanceof LightweightPeer)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2441
                    if (comp.contains(x - comp.x, y - comp.y)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2442
                        return comp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2443
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2444
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2445
            }
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2446
            for (int i = 0; i < component.size(); i++) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2447
                Component comp = component.get(i);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2448
                if (comp != null &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2449
                    comp.peer instanceof LightweightPeer) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2450
                    if (comp.contains(x - comp.x, y - comp.y)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2451
                        return comp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2452
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2453
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2454
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2455
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2456
        return this;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2457
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2458
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2459
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2460
     * Gets the component that contains the specified point.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2461
     * @param      p   the point.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2462
     * @return     returns the component that contains the point,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2463
     *                 or <code>null</code> if the component does
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2464
     *                 not contain the point.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2465
     * @see        Component#contains
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2466
     * @since      JDK1.1
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2467
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2468
    public Component getComponentAt(Point p) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2469
        return getComponentAt(p.x, p.y);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2470
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2471
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2472
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2473
     * Returns the position of the mouse pointer in this <code>Container</code>'s
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2474
     * coordinate space if the <code>Container</code> is under the mouse pointer,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2475
     * otherwise returns <code>null</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2476
     * This method is similar to {@link Component#getMousePosition()} with the exception
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2477
     * that it can take the <code>Container</code>'s children into account.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2478
     * If <code>allowChildren</code> is <code>false</code>, this method will return
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2479
     * a non-null value only if the mouse pointer is above the <code>Container</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2480
     * directly, not above the part obscured by children.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2481
     * If <code>allowChildren</code> is <code>true</code>, this method returns
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2482
     * a non-null value if the mouse pointer is above <code>Container</code> or any
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2483
     * of its descendants.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2484
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2485
     * @exception HeadlessException if GraphicsEnvironment.isHeadless() returns true
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2486
     * @param     allowChildren true if children should be taken into account
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2487
     * @see       Component#getMousePosition
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2488
     * @return    mouse coordinates relative to this <code>Component</code>, or null
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2489
     * @since     1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2490
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2491
    public Point getMousePosition(boolean allowChildren) throws HeadlessException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2492
        if (GraphicsEnvironment.isHeadless()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2493
            throw new HeadlessException();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2494
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2495
        PointerInfo pi = (PointerInfo)java.security.AccessController.doPrivileged(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2496
            new java.security.PrivilegedAction() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2497
                public Object run() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2498
                    return MouseInfo.getPointerInfo();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2499
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2500
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2501
        );
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2502
        synchronized (getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2503
            Component inTheSameWindow = findUnderMouseInWindow(pi);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2504
            if (isSameOrAncestorOf(inTheSameWindow, allowChildren)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2505
                return  pointRelativeToComponent(pi.getLocation());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2506
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2507
            return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2508
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2509
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2510
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2511
    boolean isSameOrAncestorOf(Component comp, boolean allowChildren) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2512
        return this == comp || (allowChildren && isParentOf(comp));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2513
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2514
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2515
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2516
     * Locates the visible child component that contains the specified
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2517
     * position.  The top-most child component is returned in the case
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2518
     * where there is overlap in the components.  If the containing child
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2519
     * component is a Container, this method will continue searching for
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2520
     * the deepest nested child component.  Components which are not
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2521
     * visible are ignored during the search.<p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2522
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2523
     * The findComponentAt method is different from getComponentAt in
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2524
     * that getComponentAt only searches the Container's immediate
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2525
     * children; if the containing component is a Container,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2526
     * findComponentAt will search that child to find a nested component.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2527
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2528
     * @param x the <i>x</i> coordinate
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2529
     * @param y the <i>y</i> coordinate
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2530
     * @return null if the component does not contain the position.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2531
     * If there is no child component at the requested point and the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2532
     * point is within the bounds of the container the container itself
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2533
     * is returned.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2534
     * @see Component#contains
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2535
     * @see #getComponentAt
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2536
     * @since 1.2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2537
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2538
    public Component findComponentAt(int x, int y) {
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2539
        return findComponentAt(x, y, true);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2540
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2541
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2542
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2543
     * Private version of findComponentAt which has a controllable
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2544
     * behavior. Setting 'ignoreEnabled' to 'false' bypasses disabled
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2545
     * Components during the search. This behavior is used by the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2546
     * lightweight cursor support in sun.awt.GlobalCursorManager.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2547
     * The cursor code calls this function directly via native code.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2548
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2549
     * The addition of this feature is temporary, pending the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2550
     * adoption of new, public API which exports this feature.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2551
     */
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2552
    final Component findComponentAt(int x, int y, boolean ignoreEnabled) {
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2553
        synchronized (getTreeLock()) {
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2554
            if (isRecursivelyVisible()){
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2555
                return findComponentAtImpl(x, y, ignoreEnabled);
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2556
            }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2557
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2558
        return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2559
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2560
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2561
    final Component findComponentAtImpl(int x, int y, boolean ignoreEnabled){
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2562
        checkTreeLock();
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2563
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2564
        if (!(contains(x, y) && visible && (ignoreEnabled || enabled))) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2565
            return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2566
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2567
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2568
        // Two passes: see comment in sun.awt.SunGraphicsCallback
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2569
        for (int i = 0; i < component.size(); i++) {
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2570
            Component comp = component.get(i);
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2571
            if (comp != null &&
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2572
                !(comp.peer instanceof LightweightPeer)) {
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2573
                if (comp instanceof Container) {
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2574
                    comp = ((Container)comp).findComponentAtImpl(x - comp.x,
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2575
                                                                 y - comp.y,
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2576
                                                                 ignoreEnabled);
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2577
                } else {
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2578
                    comp = comp.locate(x - comp.x, y - comp.y);
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2579
                }
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2580
                if (comp != null && comp.visible &&
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2581
                    (ignoreEnabled || comp.enabled))
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2582
                {
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2583
                    return comp;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2584
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2585
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2586
        }
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2587
        for (int i = 0; i < component.size(); i++) {
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2588
            Component comp = component.get(i);
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2589
            if (comp != null &&
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2590
                comp.peer instanceof LightweightPeer) {
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2591
                if (comp instanceof Container) {
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2592
                    comp = ((Container)comp).findComponentAtImpl(x - comp.x,
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2593
                                                                 y - comp.y,
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2594
                                                                 ignoreEnabled);
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2595
                } else {
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2596
                    comp = comp.locate(x - comp.x, y - comp.y);
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2597
                }
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2598
                if (comp != null && comp.visible &&
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2599
                    (ignoreEnabled || comp.enabled))
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2600
                {
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2601
                    return comp;
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2602
                }
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2603
            }
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2604
        }
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  2605
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2606
        return this;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2607
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2608
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2609
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2610
     * Locates the visible child component that contains the specified
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2611
     * point.  The top-most child component is returned in the case
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2612
     * where there is overlap in the components.  If the containing child
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2613
     * component is a Container, this method will continue searching for
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2614
     * the deepest nested child component.  Components which are not
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2615
     * visible are ignored during the search.<p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2616
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2617
     * The findComponentAt method is different from getComponentAt in
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2618
     * that getComponentAt only searches the Container's immediate
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2619
     * children; if the containing component is a Container,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2620
     * findComponentAt will search that child to find a nested component.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2621
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2622
     * @param      p   the point.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2623
     * @return null if the component does not contain the position.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2624
     * If there is no child component at the requested point and the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2625
     * point is within the bounds of the container the container itself
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2626
     * is returned.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2627
     * @see Component#contains
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2628
     * @see #getComponentAt
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2629
     * @since 1.2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2630
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2631
    public Component findComponentAt(Point p) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2632
        return findComponentAt(p.x, p.y);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2633
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2634
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2635
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2636
     * Makes this Container displayable by connecting it to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2637
     * a native screen resource.  Making a container displayable will
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2638
     * cause all of its children to be made displayable.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2639
     * This method is called internally by the toolkit and should
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2640
     * not be called directly by programs.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2641
     * @see Component#isDisplayable
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2642
     * @see #removeNotify
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2643
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2644
    public void addNotify() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2645
        synchronized (getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2646
            // addNotify() on the children may cause proxy event enabling
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2647
            // on this instance, so we first call super.addNotify() and
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2648
            // possibly create an lightweight event dispatcher before calling
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2649
            // addNotify() on the children which may be lightweight.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2650
            super.addNotify();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2651
            if (! (peer instanceof LightweightPeer)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2652
                dispatcher = new LightweightDispatcher(this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2653
            }
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2654
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2655
            // We shouldn't use iterator because of the Swing menu
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2656
            // implementation specifics:
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2657
            // the menu is being assigned as a child to JLayeredPane
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2658
            // instead of particular component so always affect
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2659
            // collection of component if menu is becoming shown or hidden.
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2660
            for (int i = 0; i < component.size(); i++) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2661
                component.get(i).addNotify();
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2662
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2663
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2664
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2665
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2666
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2667
     * Makes this Container undisplayable by removing its connection
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2668
     * to its native screen resource.  Making a container undisplayable
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2669
     * will cause all of its children to be made undisplayable.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2670
     * This method is called by the toolkit internally and should
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2671
     * not be called directly by programs.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2672
     * @see Component#isDisplayable
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2673
     * @see #addNotify
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2674
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2675
    public void removeNotify() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2676
        synchronized (getTreeLock()) {
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2677
            // We shouldn't use iterator because of the Swing menu
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2678
            // implementation specifics:
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2679
            // the menu is being assigned as a child to JLayeredPane
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2680
            // instead of particular component so always affect
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2681
            // collection of component if menu is becoming shown or hidden.
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2682
            for (int i = component.size()-1 ; i >= 0 ; i--) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2683
                Component comp = component.get(i);
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2684
                if (comp != null) {
441
f5da1014ed23 6607170: Focus not set by requestFocus
ant
parents: 130
diff changeset
  2685
                    // Fix for 6607170.
f5da1014ed23 6607170: Focus not set by requestFocus
ant
parents: 130
diff changeset
  2686
                    // We want to suppress focus change on disposal
f5da1014ed23 6607170: Focus not set by requestFocus
ant
parents: 130
diff changeset
  2687
                    // of the focused component. But because of focus
f5da1014ed23 6607170: Focus not set by requestFocus
ant
parents: 130
diff changeset
  2688
                    // is asynchronous, we should suppress focus change
f5da1014ed23 6607170: Focus not set by requestFocus
ant
parents: 130
diff changeset
  2689
                    // on every component in case it receives native focus
f5da1014ed23 6607170: Focus not set by requestFocus
ant
parents: 130
diff changeset
  2690
                    // in the process of disposal.
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2691
                    comp.setAutoFocusTransferOnDisposal(false);
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2692
                    comp.removeNotify();
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2693
                    comp.setAutoFocusTransferOnDisposal(true);
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2694
                 }
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2695
             }
441
f5da1014ed23 6607170: Focus not set by requestFocus
ant
parents: 130
diff changeset
  2696
            // If some of the children had focus before disposal then it still has.
f5da1014ed23 6607170: Focus not set by requestFocus
ant
parents: 130
diff changeset
  2697
            // Auto-transfer focus to the next (or previous) component if auto-transfer
f5da1014ed23 6607170: Focus not set by requestFocus
ant
parents: 130
diff changeset
  2698
            // is enabled.
f5da1014ed23 6607170: Focus not set by requestFocus
ant
parents: 130
diff changeset
  2699
            if (containsFocus() && KeyboardFocusManager.isAutoFocusTransferEnabledFor(this)) {
f5da1014ed23 6607170: Focus not set by requestFocus
ant
parents: 130
diff changeset
  2700
                if (!transferFocus(false)) {
f5da1014ed23 6607170: Focus not set by requestFocus
ant
parents: 130
diff changeset
  2701
                    transferFocusBackward(true);
f5da1014ed23 6607170: Focus not set by requestFocus
ant
parents: 130
diff changeset
  2702
                }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2703
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2704
            if ( dispatcher != null ) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2705
                dispatcher.dispose();
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2706
                dispatcher = null;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2707
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2708
            super.removeNotify();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2709
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2710
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2711
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2712
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2713
     * Checks if the component is contained in the component hierarchy of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2714
     * this container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2715
     * @param c the component
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2716
     * @return     <code>true</code> if it is an ancestor;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2717
     *             <code>false</code> otherwise.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2718
     * @since      JDK1.1
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2719
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2720
    public boolean isAncestorOf(Component c) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2721
        Container p;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2722
        if (c == null || ((p = c.getParent()) == null)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2723
            return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2724
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2725
        while (p != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2726
            if (p == this) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2727
                return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2728
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2729
            p = p.getParent();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2730
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2731
        return false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2732
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2733
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2734
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2735
     * The following code was added to support modal JInternalFrames
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2736
     * Unfortunately this code has to be added here so that we can get access to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2737
     * some private AWT classes like SequencedEvent.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2738
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2739
     * The native container of the LW component has this field set
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2740
     * to tell it that it should block Mouse events for all LW
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2741
     * children except for the modal component.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2742
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2743
     * In the case of nested Modal components, we store the previous
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2744
     * modal component in the new modal components value of modalComp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2745
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2746
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2747
    transient Component modalComp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2748
    transient AppContext modalAppContext;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2749
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2750
    private void startLWModal() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2751
        // Store the app context on which this component is being shown.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2752
        // Event dispatch thread of this app context will be sleeping until
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2753
        // we wake it by any event from hideAndDisposeHandler().
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2754
        modalAppContext = AppContext.getAppContext();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2755
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2756
        // keep the KeyEvents from being dispatched
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2757
        // until the focus has been transfered
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2758
        long time = Toolkit.getEventQueue().getMostRecentEventTime();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2759
        Component predictedFocusOwner = (Component.isInstanceOf(this, "javax.swing.JInternalFrame")) ? ((javax.swing.JInternalFrame)(this)).getMostRecentFocusOwner() : null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2760
        if (predictedFocusOwner != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2761
            KeyboardFocusManager.getCurrentKeyboardFocusManager().
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2762
                enqueueKeyEvents(time, predictedFocusOwner);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2763
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2764
        // We have two mechanisms for blocking: 1. If we're on the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2765
        // EventDispatchThread, start a new event pump. 2. If we're
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2766
        // on any other thread, call wait() on the treelock.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2767
        final Container nativeContainer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2768
        synchronized (getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2769
            nativeContainer = getHeavyweightContainer();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2770
            if (nativeContainer.modalComp != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2771
                this.modalComp =  nativeContainer.modalComp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2772
                nativeContainer.modalComp = this;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2773
                return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2774
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2775
            else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2776
                nativeContainer.modalComp = this;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2777
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2778
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2779
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2780
        Runnable pumpEventsForHierarchy = new Runnable() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2781
            public void run() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2782
                EventDispatchThread dispatchThread =
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2783
                    (EventDispatchThread)Thread.currentThread();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2784
                dispatchThread.pumpEventsForHierarchy(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2785
                        new Conditional() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2786
                        public boolean evaluate() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2787
                        return ((windowClosingException == null) && (nativeContainer.modalComp != null)) ;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2788
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2789
                        }, Container.this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2790
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2791
        };
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2792
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2793
        if (EventQueue.isDispatchThread()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2794
            SequencedEvent currentSequencedEvent =
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2795
                KeyboardFocusManager.getCurrentKeyboardFocusManager().
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2796
                getCurrentSequencedEvent();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2797
            if (currentSequencedEvent != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2798
                currentSequencedEvent.dispose();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2799
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2800
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2801
            pumpEventsForHierarchy.run();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2802
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2803
            synchronized (getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2804
                Toolkit.getEventQueue().
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2805
                    postEvent(new PeerEvent(this,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2806
                                pumpEventsForHierarchy,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2807
                                PeerEvent.PRIORITY_EVENT));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2808
                while ((windowClosingException == null) &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2809
                       (nativeContainer.modalComp != null))
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2810
                {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2811
                    try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2812
                        getTreeLock().wait();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2813
                    } catch (InterruptedException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2814
                        break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2815
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2816
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2817
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2818
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2819
        if (windowClosingException != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2820
            windowClosingException.fillInStackTrace();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2821
            throw windowClosingException;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2822
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2823
        if (predictedFocusOwner != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2824
            KeyboardFocusManager.getCurrentKeyboardFocusManager().
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2825
                dequeueKeyEvents(time, predictedFocusOwner);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2826
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2827
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2828
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2829
    private void stopLWModal() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2830
        synchronized (getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2831
            if (modalAppContext != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2832
                Container nativeContainer = getHeavyweightContainer();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2833
                if(nativeContainer != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2834
                    if (this.modalComp !=  null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2835
                        nativeContainer.modalComp = this.modalComp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2836
                        this.modalComp = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2837
                        return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2838
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2839
                    else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2840
                        nativeContainer.modalComp = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2841
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2842
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2843
                // Wake up event dispatch thread on which the dialog was
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2844
                // initially shown
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2845
                SunToolkit.postEvent(modalAppContext,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2846
                        new PeerEvent(this,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2847
                                new WakingRunnable(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2848
                                PeerEvent.PRIORITY_EVENT));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2849
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2850
            EventQueue.invokeLater(new WakingRunnable());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2851
            getTreeLock().notifyAll();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2852
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2853
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2854
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2855
    final static class WakingRunnable implements Runnable {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2856
        public void run() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2857
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2858
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2859
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2860
    /* End of JOptionPane support code */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2861
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2862
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2863
     * Returns a string representing the state of this <code>Container</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2864
     * This method is intended to be used only for debugging purposes, and the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2865
     * content and format of the returned string may vary between
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2866
     * implementations. The returned string may be empty but may not be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2867
     * <code>null</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2868
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2869
     * @return    the parameter string of this container
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2870
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2871
    protected String paramString() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2872
        String str = super.paramString();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2873
        LayoutManager layoutMgr = this.layoutMgr;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2874
        if (layoutMgr != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2875
            str += ",layout=" + layoutMgr.getClass().getName();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2876
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2877
        return str;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2878
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2879
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2880
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2881
     * Prints a listing of this container to the specified output
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2882
     * stream. The listing starts at the specified indentation.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2883
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2884
     * The immediate children of the container are printed with
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2885
     * an indentation of <code>indent+1</code>.  The children
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2886
     * of those children are printed at <code>indent+2</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2887
     * and so on.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2888
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2889
     * @param    out      a print stream
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2890
     * @param    indent   the number of spaces to indent
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2891
     * @see      Component#list(java.io.PrintStream, int)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2892
     * @since    JDK1.0
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2893
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2894
    public void list(PrintStream out, int indent) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2895
        super.list(out, indent);
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2896
        synchronized(getTreeLock()) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2897
            for (int i = 0; i < component.size(); i++) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2898
                Component comp = component.get(i);
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2899
                if (comp != null) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2900
                    comp.list(out, indent+1);
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2901
                }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2902
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2903
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2904
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2905
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2906
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2907
     * Prints out a list, starting at the specified indentation,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2908
     * to the specified print writer.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2909
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2910
     * The immediate children of the container are printed with
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2911
     * an indentation of <code>indent+1</code>.  The children
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2912
     * of those children are printed at <code>indent+2</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2913
     * and so on.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2914
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2915
     * @param    out      a print writer
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2916
     * @param    indent   the number of spaces to indent
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2917
     * @see      Component#list(java.io.PrintWriter, int)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2918
     * @since    JDK1.1
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2919
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2920
    public void list(PrintWriter out, int indent) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2921
        super.list(out, indent);
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2922
        synchronized(getTreeLock()) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2923
            for (int i = 0; i < component.size(); i++) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2924
                Component comp = component.get(i);
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2925
                if (comp != null) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2926
                    comp.list(out, indent+1);
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  2927
                }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2928
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2929
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2930
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2931
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2932
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2933
     * Sets the focus traversal keys for a given traversal operation for this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2934
     * Container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2935
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2936
     * The default values for a Container's focus traversal keys are
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2937
     * implementation-dependent. Sun recommends that all implementations for a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2938
     * particular native platform use the same default values. The
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2939
     * recommendations for Windows and Unix are listed below. These
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2940
     * recommendations are used in the Sun AWT implementations.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2941
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2942
     * <table border=1 summary="Recommended default values for a Container's focus traversal keys">
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2943
     * <tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2944
     *    <th>Identifier</th>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2945
     *    <th>Meaning</th>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2946
     *    <th>Default</th>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2947
     * </tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2948
     * <tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2949
     *    <td>KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2950
     *    <td>Normal forward keyboard traversal</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2951
     *    <td>TAB on KEY_PRESSED, CTRL-TAB on KEY_PRESSED</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2952
     * </tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2953
     * <tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2954
     *    <td>KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2955
     *    <td>Normal reverse keyboard traversal</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2956
     *    <td>SHIFT-TAB on KEY_PRESSED, CTRL-SHIFT-TAB on KEY_PRESSED</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2957
     * </tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2958
     * <tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2959
     *    <td>KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2960
     *    <td>Go up one focus traversal cycle</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2961
     *    <td>none</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2962
     * </tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2963
     * <tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2964
     *    <td>KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS<td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2965
     *    <td>Go down one focus traversal cycle</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2966
     *    <td>none</td>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2967
     * </tr>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2968
     * </table>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2969
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2970
     * To disable a traversal key, use an empty Set; Collections.EMPTY_SET is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2971
     * recommended.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2972
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2973
     * Using the AWTKeyStroke API, client code can specify on which of two
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2974
     * specific KeyEvents, KEY_PRESSED or KEY_RELEASED, the focus traversal
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2975
     * operation will occur. Regardless of which KeyEvent is specified,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2976
     * however, all KeyEvents related to the focus traversal key, including the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2977
     * associated KEY_TYPED event, will be consumed, and will not be dispatched
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2978
     * to any Container. It is a runtime error to specify a KEY_TYPED event as
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2979
     * mapping to a focus traversal operation, or to map the same event to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2980
     * multiple default focus traversal operations.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2981
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2982
     * If a value of null is specified for the Set, this Container inherits the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2983
     * Set from its parent. If all ancestors of this Container have null
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2984
     * specified for the Set, then the current KeyboardFocusManager's default
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2985
     * Set is used.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2986
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2987
     * @param id one of KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2988
     *        KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2989
     *        KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS, or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2990
     *        KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2991
     * @param keystrokes the Set of AWTKeyStroke for the specified operation
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2992
     * @see #getFocusTraversalKeys
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2993
     * @see KeyboardFocusManager#FORWARD_TRAVERSAL_KEYS
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2994
     * @see KeyboardFocusManager#BACKWARD_TRAVERSAL_KEYS
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2995
     * @see KeyboardFocusManager#UP_CYCLE_TRAVERSAL_KEYS
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2996
     * @see KeyboardFocusManager#DOWN_CYCLE_TRAVERSAL_KEYS
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2997
     * @throws IllegalArgumentException if id is not one of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2998
     *         KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  2999
     *         KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3000
     *         KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS, or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3001
     *         KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS, or if keystrokes
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3002
     *         contains null, or if any Object in keystrokes is not an
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3003
     *         AWTKeyStroke, or if any keystroke represents a KEY_TYPED event,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3004
     *         or if any keystroke already maps to another focus traversal
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3005
     *         operation for this Container
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3006
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3007
     * @beaninfo
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3008
     *       bound: true
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3009
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3010
    public void setFocusTraversalKeys(int id,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3011
                                      Set<? extends AWTKeyStroke> keystrokes)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3012
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3013
        if (id < 0 || id >= KeyboardFocusManager.TRAVERSAL_KEY_LENGTH) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3014
            throw new IllegalArgumentException("invalid focus traversal key identifier");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3015
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3016
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3017
        // Don't call super.setFocusTraversalKey. The Component parameter check
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3018
        // does not allow DOWN_CYCLE_TRAVERSAL_KEYS, but we do.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3019
        setFocusTraversalKeys_NoIDCheck(id, keystrokes);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3020
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3021
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3022
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3023
     * Returns the Set of focus traversal keys for a given traversal operation
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3024
     * for this Container. (See
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3025
     * <code>setFocusTraversalKeys</code> for a full description of each key.)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3026
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3027
     * If a Set of traversal keys has not been explicitly defined for this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3028
     * Container, then this Container's parent's Set is returned. If no Set
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3029
     * has been explicitly defined for any of this Container's ancestors, then
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3030
     * the current KeyboardFocusManager's default Set is returned.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3031
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3032
     * @param id one of KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3033
     *        KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3034
     *        KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS, or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3035
     *        KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3036
     * @return the Set of AWTKeyStrokes for the specified operation. The Set
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3037
     *         will be unmodifiable, and may be empty. null will never be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3038
     *         returned.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3039
     * @see #setFocusTraversalKeys
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3040
     * @see KeyboardFocusManager#FORWARD_TRAVERSAL_KEYS
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3041
     * @see KeyboardFocusManager#BACKWARD_TRAVERSAL_KEYS
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3042
     * @see KeyboardFocusManager#UP_CYCLE_TRAVERSAL_KEYS
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3043
     * @see KeyboardFocusManager#DOWN_CYCLE_TRAVERSAL_KEYS
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3044
     * @throws IllegalArgumentException if id is not one of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3045
     *         KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3046
     *         KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3047
     *         KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS, or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3048
     *         KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3049
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3050
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3051
    public Set<AWTKeyStroke> getFocusTraversalKeys(int id) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3052
        if (id < 0 || id >= KeyboardFocusManager.TRAVERSAL_KEY_LENGTH) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3053
            throw new IllegalArgumentException("invalid focus traversal key identifier");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3054
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3055
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3056
        // Don't call super.getFocusTraversalKey. The Component parameter check
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3057
        // does not allow DOWN_CYCLE_TRAVERSAL_KEY, but we do.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3058
        return getFocusTraversalKeys_NoIDCheck(id);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3059
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3060
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3061
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3062
     * Returns whether the Set of focus traversal keys for the given focus
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3063
     * traversal operation has been explicitly defined for this Container. If
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3064
     * this method returns <code>false</code>, this Container is inheriting the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3065
     * Set from an ancestor, or from the current KeyboardFocusManager.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3066
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3067
     * @param id one of KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3068
     *        KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3069
     *        KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS, or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3070
     *        KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3071
     * @return <code>true</code> if the the Set of focus traversal keys for the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3072
     *         given focus traversal operation has been explicitly defined for
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3073
     *         this Component; <code>false</code> otherwise.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3074
     * @throws IllegalArgumentException if id is not one of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3075
     *         KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3076
     *        KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3077
     *        KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS, or
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3078
     *        KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3079
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3080
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3081
    public boolean areFocusTraversalKeysSet(int id) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3082
        if (id < 0 || id >= KeyboardFocusManager.TRAVERSAL_KEY_LENGTH) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3083
            throw new IllegalArgumentException("invalid focus traversal key identifier");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3084
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3085
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3086
        return (focusTraversalKeys != null && focusTraversalKeys[id] != null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3087
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3088
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3089
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3090
     * Returns whether the specified Container is the focus cycle root of this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3091
     * Container's focus traversal cycle. Each focus traversal cycle has only
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3092
     * a single focus cycle root and each Container which is not a focus cycle
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3093
     * root belongs to only a single focus traversal cycle. Containers which
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3094
     * are focus cycle roots belong to two cycles: one rooted at the Container
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3095
     * itself, and one rooted at the Container's nearest focus-cycle-root
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3096
     * ancestor. This method will return <code>true</code> for both such
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3097
     * Containers in this case.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3098
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3099
     * @param container the Container to be tested
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3100
     * @return <code>true</code> if the specified Container is a focus-cycle-
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3101
     *         root of this Container; <code>false</code> otherwise
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3102
     * @see #isFocusCycleRoot()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3103
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3104
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3105
    public boolean isFocusCycleRoot(Container container) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3106
        if (isFocusCycleRoot() && container == this) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3107
            return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3108
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3109
            return super.isFocusCycleRoot(container);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3110
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3111
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3112
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3113
    private Container findTraversalRoot() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3114
        // I potentially have two roots, myself and my root parent
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3115
        // If I am the current root, then use me
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3116
        // If none of my parents are roots, then use me
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3117
        // If my root parent is the current root, then use my root parent
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3118
        // If neither I nor my root parent is the current root, then
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3119
        // use my root parent (a guess)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3120
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3121
        Container currentFocusCycleRoot = KeyboardFocusManager.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3122
            getCurrentKeyboardFocusManager().getCurrentFocusCycleRoot();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3123
        Container root;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3124
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3125
        if (currentFocusCycleRoot == this) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3126
            root = this;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3127
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3128
            root = getFocusCycleRootAncestor();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3129
            if (root == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3130
                root = this;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3131
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3132
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3133
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3134
        if (root != currentFocusCycleRoot) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3135
            KeyboardFocusManager.getCurrentKeyboardFocusManager().
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3136
                setGlobalCurrentFocusCycleRoot(root);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3137
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3138
        return root;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3139
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3140
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3141
    final boolean containsFocus() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3142
        final Component focusOwner = KeyboardFocusManager.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3143
            getCurrentKeyboardFocusManager().getFocusOwner();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3144
        return isParentOf(focusOwner);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3145
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3146
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3147
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3148
     * Check if this component is the child of this container or its children.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3149
     * Note: this function acquires treeLock
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3150
     * Note: this function traverses children tree only in one Window.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3151
     * @param comp a component in test, must not be null
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3152
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3153
    private boolean isParentOf(Component comp) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3154
        synchronized(getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3155
            while (comp != null && comp != this && !(comp instanceof Window)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3156
                comp = comp.getParent();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3157
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3158
            return (comp == this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3159
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3160
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3161
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3162
    void clearMostRecentFocusOwnerOnHide() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3163
        boolean reset = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3164
        Window window = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3165
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3166
        synchronized (getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3167
            window = getContainingWindow();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3168
            if (window != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3169
                Component comp = KeyboardFocusManager.getMostRecentFocusOwner(window);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3170
                reset = ((comp == this) || isParentOf(comp));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3171
                // This synchronized should always be the second in a pair
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3172
                // (tree lock, KeyboardFocusManager.class)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3173
                synchronized(KeyboardFocusManager.class) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3174
                    Component storedComp = window.getTemporaryLostComponent();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3175
                    if (isParentOf(storedComp) || storedComp == this) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3176
                        window.setTemporaryLostComponent(null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3177
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3178
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3179
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3180
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3181
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3182
        if (reset) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3183
            KeyboardFocusManager.setMostRecentFocusOwner(window, null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3184
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3185
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3186
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3187
    void clearCurrentFocusCycleRootOnHide() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3188
        KeyboardFocusManager kfm =
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3189
            KeyboardFocusManager.getCurrentKeyboardFocusManager();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3190
        Container cont = kfm.getCurrentFocusCycleRoot();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3191
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3192
        if (cont == this || isParentOf(cont)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3193
            kfm.setGlobalCurrentFocusCycleRoot(null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3194
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3195
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3196
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3197
    final Container getTraversalRoot() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3198
        if (isFocusCycleRoot()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3199
            return findTraversalRoot();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3200
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3201
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3202
        return super.getTraversalRoot();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3203
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3204
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3205
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3206
     * Sets the focus traversal policy that will manage keyboard traversal of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3207
     * this Container's children, if this Container is a focus cycle root. If
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3208
     * the argument is null, this Container inherits its policy from its focus-
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3209
     * cycle-root ancestor. If the argument is non-null, this policy will be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3210
     * inherited by all focus-cycle-root children that have no keyboard-
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3211
     * traversal policy of their own (as will, recursively, their focus-cycle-
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3212
     * root children).
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3213
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3214
     * If this Container is not a focus cycle root, the policy will be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3215
     * remembered, but will not be used or inherited by this or any other
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3216
     * Containers until this Container is made a focus cycle root.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3217
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3218
     * @param policy the new focus traversal policy for this Container
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3219
     * @see #getFocusTraversalPolicy
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3220
     * @see #setFocusCycleRoot
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3221
     * @see #isFocusCycleRoot
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3222
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3223
     * @beaninfo
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3224
     *       bound: true
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3225
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3226
    public void setFocusTraversalPolicy(FocusTraversalPolicy policy) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3227
        FocusTraversalPolicy oldPolicy;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3228
        synchronized (this) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3229
            oldPolicy = this.focusTraversalPolicy;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3230
            this.focusTraversalPolicy = policy;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3231
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3232
        firePropertyChange("focusTraversalPolicy", oldPolicy, policy);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3233
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3234
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3235
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3236
     * Returns the focus traversal policy that will manage keyboard traversal
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3237
     * of this Container's children, or null if this Container is not a focus
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3238
     * cycle root. If no traversal policy has been explicitly set for this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3239
     * Container, then this Container's focus-cycle-root ancestor's policy is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3240
     * returned.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3241
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3242
     * @return this Container's focus traversal policy, or null if this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3243
     *         Container is not a focus cycle root.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3244
     * @see #setFocusTraversalPolicy
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3245
     * @see #setFocusCycleRoot
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3246
     * @see #isFocusCycleRoot
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3247
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3248
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3249
    public FocusTraversalPolicy getFocusTraversalPolicy() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3250
        if (!isFocusTraversalPolicyProvider() && !isFocusCycleRoot()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3251
            return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3252
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3253
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3254
        FocusTraversalPolicy policy = this.focusTraversalPolicy;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3255
        if (policy != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3256
            return policy;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3257
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3258
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3259
        Container rootAncestor = getFocusCycleRootAncestor();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3260
        if (rootAncestor != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3261
            return rootAncestor.getFocusTraversalPolicy();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3262
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3263
            return KeyboardFocusManager.getCurrentKeyboardFocusManager().
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3264
                getDefaultFocusTraversalPolicy();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3265
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3266
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3267
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3268
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3269
     * Returns whether the focus traversal policy has been explicitly set for
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3270
     * this Container. If this method returns <code>false</code>, this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3271
     * Container will inherit its focus traversal policy from an ancestor.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3272
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3273
     * @return <code>true</code> if the focus traversal policy has been
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3274
     *         explicitly set for this Container; <code>false</code> otherwise.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3275
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3276
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3277
    public boolean isFocusTraversalPolicySet() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3278
        return (focusTraversalPolicy != null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3279
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3280
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3281
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3282
     * Sets whether this Container is the root of a focus traversal cycle. Once
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3283
     * focus enters a traversal cycle, typically it cannot leave it via focus
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3284
     * traversal unless one of the up- or down-cycle keys is pressed. Normal
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3285
     * traversal is limited to this Container, and all of this Container's
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3286
     * descendants that are not descendants of inferior focus cycle roots. Note
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3287
     * that a FocusTraversalPolicy may bend these restrictions, however. For
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3288
     * example, ContainerOrderFocusTraversalPolicy supports implicit down-cycle
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3289
     * traversal.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3290
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3291
     * The alternative way to specify the traversal order of this Container's
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3292
     * children is to make this Container a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3293
     * <a href="doc-files/FocusSpec.html#FocusTraversalPolicyProviders">focus traversal policy provider</a>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3294
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3295
     * @param focusCycleRoot indicates whether this Container is the root of a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3296
     *        focus traversal cycle
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3297
     * @see #isFocusCycleRoot()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3298
     * @see #setFocusTraversalPolicy
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3299
     * @see #getFocusTraversalPolicy
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3300
     * @see ContainerOrderFocusTraversalPolicy
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3301
     * @see #setFocusTraversalPolicyProvider
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3302
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3303
     * @beaninfo
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3304
     *       bound: true
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3305
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3306
    public void setFocusCycleRoot(boolean focusCycleRoot) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3307
        boolean oldFocusCycleRoot;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3308
        synchronized (this) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3309
            oldFocusCycleRoot = this.focusCycleRoot;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3310
            this.focusCycleRoot = focusCycleRoot;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3311
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3312
        firePropertyChange("focusCycleRoot", oldFocusCycleRoot,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3313
                           focusCycleRoot);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3314
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3315
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3316
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3317
     * Returns whether this Container is the root of a focus traversal cycle.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3318
     * Once focus enters a traversal cycle, typically it cannot leave it via
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3319
     * focus traversal unless one of the up- or down-cycle keys is pressed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3320
     * Normal traversal is limited to this Container, and all of this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3321
     * Container's descendants that are not descendants of inferior focus
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3322
     * cycle roots. Note that a FocusTraversalPolicy may bend these
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3323
     * restrictions, however. For example, ContainerOrderFocusTraversalPolicy
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3324
     * supports implicit down-cycle traversal.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3325
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3326
     * @return whether this Container is the root of a focus traversal cycle
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3327
     * @see #setFocusCycleRoot
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3328
     * @see #setFocusTraversalPolicy
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3329
     * @see #getFocusTraversalPolicy
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3330
     * @see ContainerOrderFocusTraversalPolicy
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3331
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3332
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3333
    public boolean isFocusCycleRoot() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3334
        return focusCycleRoot;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3335
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3336
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3337
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3338
     * Sets whether this container will be used to provide focus
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3339
     * traversal policy. Container with this property as
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3340
     * <code>true</code> will be used to acquire focus traversal policy
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3341
     * instead of closest focus cycle root ancestor.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3342
     * @param provider indicates whether this container will be used to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3343
     *                provide focus traversal policy
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3344
     * @see #setFocusTraversalPolicy
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3345
     * @see #getFocusTraversalPolicy
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3346
     * @see #isFocusTraversalPolicyProvider
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3347
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3348
     * @beaninfo
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3349
     *        bound: true
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3350
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3351
    public final void setFocusTraversalPolicyProvider(boolean provider) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3352
        boolean oldProvider;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3353
        synchronized(this) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3354
            oldProvider = focusTraversalPolicyProvider;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3355
            focusTraversalPolicyProvider = provider;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3356
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3357
        firePropertyChange("focusTraversalPolicyProvider", oldProvider, provider);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3358
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3359
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3360
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3361
     * Returns whether this container provides focus traversal
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3362
     * policy. If this property is set to <code>true</code> then when
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3363
     * keyboard focus manager searches container hierarchy for focus
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3364
     * traversal policy and encounters this container before any other
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3365
     * container with this property as true or focus cycle roots then
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3366
     * its focus traversal policy will be used instead of focus cycle
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3367
     * root's policy.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3368
     * @see #setFocusTraversalPolicy
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3369
     * @see #getFocusTraversalPolicy
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3370
     * @see #setFocusCycleRoot
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3371
     * @see #setFocusTraversalPolicyProvider
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3372
     * @return <code>true</code> if this container provides focus traversal
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3373
     *         policy, <code>false</code> otherwise
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3374
     * @since 1.5
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3375
     * @beaninfo
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3376
     *        bound: true
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3377
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3378
    public final boolean isFocusTraversalPolicyProvider() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3379
        return focusTraversalPolicyProvider;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3380
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3381
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3382
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3383
     * Transfers the focus down one focus traversal cycle. If this Container is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3384
     * a focus cycle root, then the focus owner is set to this Container's
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3385
     * default Component to focus, and the current focus cycle root is set to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3386
     * this Container. If this Container is not a focus cycle root, then no
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3387
     * focus traversal operation occurs.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3388
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3389
     * @see       Component#requestFocus()
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3390
     * @see       #isFocusCycleRoot
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3391
     * @see       #setFocusCycleRoot
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3392
     * @since     1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3393
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3394
    public void transferFocusDownCycle() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3395
        if (isFocusCycleRoot()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3396
            KeyboardFocusManager.getCurrentKeyboardFocusManager().
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3397
                setGlobalCurrentFocusCycleRoot(this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3398
            Component toFocus = getFocusTraversalPolicy().
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3399
                getDefaultComponent(this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3400
            if (toFocus != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3401
                toFocus.requestFocus(CausedFocusEvent.Cause.TRAVERSAL_DOWN);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3402
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3403
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3404
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3405
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3406
    void preProcessKeyEvent(KeyEvent e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3407
        Container parent = this.parent;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3408
        if (parent != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3409
            parent.preProcessKeyEvent(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3410
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3411
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3412
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3413
    void postProcessKeyEvent(KeyEvent e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3414
        Container parent = this.parent;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3415
        if (parent != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3416
            parent.postProcessKeyEvent(e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3417
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3418
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3419
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3420
    boolean postsOldMouseEvents() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3421
        return true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3422
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3423
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3424
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3425
     * Sets the <code>ComponentOrientation</code> property of this container
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3426
     * and all components contained within it.
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  3427
     * <p>
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  3428
     * This method changes layout-related information, and therefore,
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  3429
     * invalidates the component hierarchy.
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3430
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3431
     * @param o the new component orientation of this container and
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3432
     *        the components contained within it.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3433
     * @exception NullPointerException if <code>orientation</code> is null.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3434
     * @see Component#setComponentOrientation
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3435
     * @see Component#getComponentOrientation
3966
0ce65d9e45e2 6868255: Requirements for correct operating of the HW/LW Mixing feature need to be specified
anthony
parents: 2805
diff changeset
  3436
     * @see #invalidate
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3437
     * @since 1.4
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3438
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3439
    public void applyComponentOrientation(ComponentOrientation o) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3440
        super.applyComponentOrientation(o);
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  3441
        synchronized (getTreeLock()) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  3442
            for (int i = 0; i < component.size(); i++) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  3443
                Component comp = component.get(i);
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  3444
                comp.applyComponentOrientation(o);
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  3445
            }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3446
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3447
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3448
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3449
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3450
     * Adds a PropertyChangeListener to the listener list. The listener is
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3451
     * registered for all bound properties of this class, including the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3452
     * following:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3453
     * <ul>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3454
     *    <li>this Container's font ("font")</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3455
     *    <li>this Container's background color ("background")</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3456
     *    <li>this Container's foreground color ("foreground")</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3457
     *    <li>this Container's focusability ("focusable")</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3458
     *    <li>this Container's focus traversal keys enabled state
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3459
     *        ("focusTraversalKeysEnabled")</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3460
     *    <li>this Container's Set of FORWARD_TRAVERSAL_KEYS
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3461
     *        ("forwardFocusTraversalKeys")</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3462
     *    <li>this Container's Set of BACKWARD_TRAVERSAL_KEYS
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3463
     *        ("backwardFocusTraversalKeys")</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3464
     *    <li>this Container's Set of UP_CYCLE_TRAVERSAL_KEYS
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3465
     *        ("upCycleFocusTraversalKeys")</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3466
     *    <li>this Container's Set of DOWN_CYCLE_TRAVERSAL_KEYS
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3467
     *        ("downCycleFocusTraversalKeys")</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3468
     *    <li>this Container's focus traversal policy ("focusTraversalPolicy")
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3469
     *        </li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3470
     *    <li>this Container's focus-cycle-root state ("focusCycleRoot")</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3471
     * </ul>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3472
     * Note that if this Container is inheriting a bound property, then no
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3473
     * event will be fired in response to a change in the inherited property.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3474
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3475
     * If listener is null, no exception is thrown and no action is performed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3476
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3477
     * @param    listener  the PropertyChangeListener to be added
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3478
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3479
     * @see Component#removePropertyChangeListener
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3480
     * @see #addPropertyChangeListener(java.lang.String,java.beans.PropertyChangeListener)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3481
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3482
    public void addPropertyChangeListener(PropertyChangeListener listener) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3483
        super.addPropertyChangeListener(listener);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3484
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3485
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3486
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3487
     * Adds a PropertyChangeListener to the listener list for a specific
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3488
     * property. The specified property may be user-defined, or one of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3489
     * following defaults:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3490
     * <ul>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3491
     *    <li>this Container's font ("font")</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3492
     *    <li>this Container's background color ("background")</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3493
     *    <li>this Container's foreground color ("foreground")</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3494
     *    <li>this Container's focusability ("focusable")</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3495
     *    <li>this Container's focus traversal keys enabled state
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3496
     *        ("focusTraversalKeysEnabled")</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3497
     *    <li>this Container's Set of FORWARD_TRAVERSAL_KEYS
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3498
     *        ("forwardFocusTraversalKeys")</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3499
     *    <li>this Container's Set of BACKWARD_TRAVERSAL_KEYS
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3500
     *        ("backwardFocusTraversalKeys")</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3501
     *    <li>this Container's Set of UP_CYCLE_TRAVERSAL_KEYS
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3502
     *        ("upCycleFocusTraversalKeys")</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3503
     *    <li>this Container's Set of DOWN_CYCLE_TRAVERSAL_KEYS
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3504
     *        ("downCycleFocusTraversalKeys")</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3505
     *    <li>this Container's focus traversal policy ("focusTraversalPolicy")
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3506
     *        </li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3507
     *    <li>this Container's focus-cycle-root state ("focusCycleRoot")</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3508
     *    <li>this Container's focus-traversal-policy-provider state("focusTraversalPolicyProvider")</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3509
     *    <li>this Container's focus-traversal-policy-provider state("focusTraversalPolicyProvider")</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3510
     * </ul>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3511
     * Note that if this Container is inheriting a bound property, then no
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3512
     * event will be fired in response to a change in the inherited property.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3513
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3514
     * If listener is null, no exception is thrown and no action is performed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3515
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3516
     * @param propertyName one of the property names listed above
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3517
     * @param listener the PropertyChangeListener to be added
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3518
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3519
     * @see #addPropertyChangeListener(java.beans.PropertyChangeListener)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3520
     * @see Component#removePropertyChangeListener
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3521
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3522
    public void addPropertyChangeListener(String propertyName,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3523
                                          PropertyChangeListener listener) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3524
        super.addPropertyChangeListener(propertyName, listener);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3525
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3526
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3527
    // Serialization support. A Container is responsible for restoring the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3528
    // parent fields of its component children.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3529
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3530
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3531
     * Container Serial Data Version.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3532
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3533
    private int containerSerializedDataVersion = 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3534
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3535
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3536
     * Serializes this <code>Container</code> to the specified
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3537
     * <code>ObjectOutputStream</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3538
     * <ul>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3539
     *    <li>Writes default serializable fields to the stream.</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3540
     *    <li>Writes a list of serializable ContainerListener(s) as optional
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3541
     *        data. The non-serializable ContainerListner(s) are detected and
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3542
     *        no attempt is made to serialize them.</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3543
     *    <li>Write this Container's FocusTraversalPolicy if and only if it
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3544
     *        is Serializable; otherwise, <code>null</code> is written.</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3545
     * </ul>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3546
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3547
     * @param s the <code>ObjectOutputStream</code> to write
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3548
     * @serialData <code>null</code> terminated sequence of 0 or more pairs;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3549
     *   the pair consists of a <code>String</code> and <code>Object</code>;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3550
     *   the <code>String</code> indicates the type of object and
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3551
     *   is one of the following:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3552
     *   <code>containerListenerK</code> indicating an
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3553
     *     <code>ContainerListener</code> object;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3554
     *   the <code>Container</code>'s <code>FocusTraversalPolicy</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3555
     *     or <code>null</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3556
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3557
     * @see AWTEventMulticaster#save(java.io.ObjectOutputStream, java.lang.String, java.util.EventListener)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3558
     * @see Container#containerListenerK
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3559
     * @see #readObject(ObjectInputStream)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3560
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3561
    private void writeObject(ObjectOutputStream s) throws IOException {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3562
        ObjectOutputStream.PutField f = s.putFields();
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  3563
        f.put("ncomponents", component.size());
2463
c90a9d542c79 6784816: Remove AWT tree lock from Container methods: getComponent, getComponents, getComponentCount
art
parents: 2462
diff changeset
  3564
        f.put("component", getComponentsSync());
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3565
        f.put("layoutMgr", layoutMgr);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3566
        f.put("dispatcher", dispatcher);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3567
        f.put("maxSize", maxSize);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3568
        f.put("focusCycleRoot", focusCycleRoot);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3569
        f.put("containerSerializedDataVersion", containerSerializedDataVersion);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3570
        f.put("focusTraversalPolicyProvider", focusTraversalPolicyProvider);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3571
        s.writeFields();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3572
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3573
        AWTEventMulticaster.save(s, containerListenerK, containerListener);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3574
        s.writeObject(null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3575
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3576
        if (focusTraversalPolicy instanceof java.io.Serializable) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3577
            s.writeObject(focusTraversalPolicy);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3578
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3579
            s.writeObject(null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3580
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3581
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3582
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3583
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3584
     * Deserializes this <code>Container</code> from the specified
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3585
     * <code>ObjectInputStream</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3586
     * <ul>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3587
     *    <li>Reads default serializable fields from the stream.</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3588
     *    <li>Reads a list of serializable ContainerListener(s) as optional
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3589
     *        data. If the list is null, no Listeners are installed.</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3590
     *    <li>Reads this Container's FocusTraversalPolicy, which may be null,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3591
     *        as optional data.</li>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3592
     * </ul>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3593
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3594
     * @param s the <code>ObjectInputStream</code> to read
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3595
     * @serial
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3596
     * @see #addContainerListener
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3597
     * @see #writeObject(ObjectOutputStream)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3598
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3599
    private void readObject(ObjectInputStream s)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3600
        throws ClassNotFoundException, IOException
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3601
    {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3602
        ObjectInputStream.GetField f = s.readFields();
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  3603
        Component [] tmpComponent = (Component[])f.get("component", EMPTY_ARRAY);
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  3604
        int ncomponents = (Integer) f.get("ncomponents", 0);
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  3605
        component = new java.util.ArrayList<Component>(ncomponents);
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  3606
        for (int i = 0; i < ncomponents; ++i) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  3607
            component.add(tmpComponent[i]);
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  3608
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3609
        layoutMgr = (LayoutManager)f.get("layoutMgr", null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3610
        dispatcher = (LightweightDispatcher)f.get("dispatcher", null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3611
        // Old stream. Doesn't contain maxSize among Component's fields.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3612
        if (maxSize == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3613
            maxSize = (Dimension)f.get("maxSize", null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3614
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3615
        focusCycleRoot = f.get("focusCycleRoot", false);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3616
        containerSerializedDataVersion = f.get("containerSerializedDataVersion", 1);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3617
        focusTraversalPolicyProvider = f.get("focusTraversalPolicyProvider", false);
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  3618
        java.util.List<Component> component = this.component;
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  3619
        for(Component comp : component) {
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  3620
            comp.parent = this;
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3621
            adjustListeningChildren(AWTEvent.HIERARCHY_EVENT_MASK,
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  3622
                                    comp.numListening(AWTEvent.HIERARCHY_EVENT_MASK));
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3623
            adjustListeningChildren(AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK,
1172
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  3624
                                    comp.numListening(AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK));
a1d23c450f84 6616323: consider benefits of replacing a componen array with other collection from the awt.Container class
dav
parents: 1171
diff changeset
  3625
            adjustDescendants(comp.countHierarchyMembers());
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3626
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3627
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3628
        Object keyOrNull;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3629
        while(null != (keyOrNull = s.readObject())) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3630
            String key = ((String)keyOrNull).intern();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3631
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3632
            if (containerListenerK == key) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3633
                addContainerListener((ContainerListener)(s.readObject()));
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3634
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3635
                // skip value for unrecognized key
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3636
                s.readObject();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3637
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3638
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3639
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3640
        try {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3641
            Object policy = s.readObject();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3642
            if (policy instanceof FocusTraversalPolicy) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3643
                focusTraversalPolicy = (FocusTraversalPolicy)policy;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3644
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3645
        } catch (java.io.OptionalDataException e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3646
            // JDK 1.1/1.2/1.3 instances will not have this optional data.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3647
            // e.eof will be true to indicate that there is no more data
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3648
            // available for this object. If e.eof is not true, throw the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3649
            // exception as it might have been caused by reasons unrelated to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3650
            // focusTraversalPolicy.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3651
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3652
            if (!e.eof) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3653
                throw e;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3654
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3655
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3656
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3657
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3658
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3659
     * --- Accessibility Support ---
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3660
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3661
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3662
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3663
     * Inner class of Container used to provide default support for
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3664
     * accessibility.  This class is not meant to be used directly by
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3665
     * application developers, but is instead meant only to be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3666
     * subclassed by container developers.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3667
     * <p>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3668
     * The class used to obtain the accessible role for this object,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3669
     * as well as implementing many of the methods in the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3670
     * AccessibleContainer interface.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3671
     * @since 1.3
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3672
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3673
    protected class AccessibleAWTContainer extends AccessibleAWTComponent {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3674
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3675
        /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3676
         * JDK1.3 serialVersionUID
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3677
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3678
        private static final long serialVersionUID = 5081320404842566097L;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3679
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3680
        /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3681
         * Returns the number of accessible children in the object.  If all
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3682
         * of the children of this object implement <code>Accessible</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3683
         * then this method should return the number of children of this object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3684
         *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3685
         * @return the number of accessible children in the object
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3686
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3687
        public int getAccessibleChildrenCount() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3688
            return Container.this.getAccessibleChildrenCount();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3689
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3690
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3691
        /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3692
         * Returns the nth <code>Accessible</code> child of the object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3693
         *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3694
         * @param i zero-based index of child
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3695
         * @return the nth <code>Accessible</code> child of the object
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3696
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3697
        public Accessible getAccessibleChild(int i) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3698
            return Container.this.getAccessibleChild(i);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3699
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3700
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3701
        /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3702
         * Returns the <code>Accessible</code> child, if one exists,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3703
         * contained at the local coordinate <code>Point</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3704
         *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3705
         * @param p the point defining the top-left corner of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3706
         *    <code>Accessible</code>, given in the coordinate space
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3707
         *    of the object's parent
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3708
         * @return the <code>Accessible</code>, if it exists,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3709
         *    at the specified location; else <code>null</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3710
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3711
        public Accessible getAccessibleAt(Point p) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3712
            return Container.this.getAccessibleAt(p);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3713
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3714
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3715
        protected ContainerListener accessibleContainerHandler = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3716
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3717
        /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3718
         * Fire <code>PropertyChange</code> listener, if one is registered,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3719
         * when children are added or removed.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3720
         * @since 1.3
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3721
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3722
        protected class AccessibleContainerHandler
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3723
            implements ContainerListener {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3724
            public void componentAdded(ContainerEvent e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3725
                Component c = e.getChild();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3726
                if (c != null && c instanceof Accessible) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3727
                    AccessibleAWTContainer.this.firePropertyChange(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3728
                        AccessibleContext.ACCESSIBLE_CHILD_PROPERTY,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3729
                        null, ((Accessible) c).getAccessibleContext());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3730
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3731
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3732
            public void componentRemoved(ContainerEvent e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3733
                Component c = e.getChild();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3734
                if (c != null && c instanceof Accessible) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3735
                    AccessibleAWTContainer.this.firePropertyChange(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3736
                        AccessibleContext.ACCESSIBLE_CHILD_PROPERTY,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3737
                        ((Accessible) c).getAccessibleContext(), null);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3738
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3739
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3740
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3741
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3742
        /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3743
         * Adds a PropertyChangeListener to the listener list.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3744
         *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3745
         * @param listener  the PropertyChangeListener to be added
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3746
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3747
        public void addPropertyChangeListener(PropertyChangeListener listener) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3748
            if (accessibleContainerHandler == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3749
                accessibleContainerHandler = new AccessibleContainerHandler();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3750
                Container.this.addContainerListener(accessibleContainerHandler);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3751
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3752
            super.addPropertyChangeListener(listener);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3753
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3754
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3755
    } // inner class AccessibleAWTContainer
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3756
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3757
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3758
     * Returns the <code>Accessible</code> child contained at the local
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3759
     * coordinate <code>Point</code>, if one exists.  Otherwise
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3760
     * returns <code>null</code>.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3761
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3762
     * @param p the point defining the top-left corner of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3763
     *    <code>Accessible</code>, given in the coordinate space
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3764
     *    of the object's parent
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3765
     * @return the <code>Accessible</code> at the specified location,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3766
     *    if it exists; otherwise <code>null</code>
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3767
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3768
    Accessible getAccessibleAt(Point p) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3769
        synchronized (getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3770
            if (this instanceof Accessible) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3771
                Accessible a = (Accessible)this;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3772
                AccessibleContext ac = a.getAccessibleContext();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3773
                if (ac != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3774
                    AccessibleComponent acmp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3775
                    Point location;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3776
                    int nchildren = ac.getAccessibleChildrenCount();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3777
                    for (int i=0; i < nchildren; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3778
                        a = ac.getAccessibleChild(i);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3779
                        if ((a != null)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3780
                            ac = a.getAccessibleContext();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3781
                            if (ac != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3782
                                acmp = ac.getAccessibleComponent();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3783
                                if ((acmp != null) && (acmp.isShowing())) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3784
                                    location = acmp.getLocation();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3785
                                    Point np = new Point(p.x-location.x,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3786
                                                         p.y-location.y);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3787
                                    if (acmp.contains(np)){
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3788
                                        return a;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3789
                                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3790
                                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3791
                            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3792
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3793
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3794
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3795
                return (Accessible)this;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3796
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3797
                Component ret = this;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3798
                if (!this.contains(p.x,p.y)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3799
                    ret = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3800
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3801
                    int ncomponents = this.getComponentCount();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3802
                    for (int i=0; i < ncomponents; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3803
                        Component comp = this.getComponent(i);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3804
                        if ((comp != null) && comp.isShowing()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3805
                            Point location = comp.getLocation();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3806
                            if (comp.contains(p.x-location.x,p.y-location.y)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3807
                                ret = comp;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3808
                            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3809
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3810
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3811
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3812
                if (ret instanceof Accessible) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3813
                    return (Accessible) ret;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3814
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3815
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3816
            return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3817
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3818
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3819
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3820
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3821
     * Returns the number of accessible children in the object.  If all
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3822
     * of the children of this object implement <code>Accessible</code>,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3823
     * then this method should return the number of children of this object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3824
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3825
     * @return the number of accessible children in the object
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3826
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3827
    int getAccessibleChildrenCount() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3828
        synchronized (getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3829
            int count = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3830
            Component[] children = this.getComponents();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3831
            for (int i = 0; i < children.length; i++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3832
                if (children[i] instanceof Accessible) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3833
                    count++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3834
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3835
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3836
            return count;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3837
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3838
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3839
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3840
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3841
     * Returns the nth <code>Accessible</code> child of the object.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3842
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3843
     * @param i zero-based index of child
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3844
     * @return the nth <code>Accessible</code> child of the object
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3845
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3846
    Accessible getAccessibleChild(int i) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3847
        synchronized (getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3848
            Component[] children = this.getComponents();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3849
            int count = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3850
            for (int j = 0; j < children.length; j++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3851
                if (children[j] instanceof Accessible) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3852
                    if (count == i) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3853
                        return (Accessible) children[j];
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3854
                    } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3855
                        count++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3856
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3857
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3858
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3859
            return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3860
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3861
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3862
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3863
    // ************************** MIXING CODE *******************************
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3864
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3865
    final void increaseComponentCount(Component c) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3866
        synchronized (getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3867
            if (!c.isDisplayable()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3868
                throw new IllegalStateException(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3869
                    "Peer does not exist while invoking the increaseComponentCount() method"
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3870
                );
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3871
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3872
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3873
            int addHW = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3874
            int addLW = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3875
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3876
            if (c instanceof Container) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3877
                addLW = ((Container)c).numOfLWComponents;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3878
                addHW = ((Container)c).numOfHWComponents;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3879
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3880
            if (c.isLightweight()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3881
                addLW++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3882
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3883
                addHW++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3884
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3885
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3886
            for (Container cont = this; cont != null; cont = cont.getContainer()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3887
                cont.numOfLWComponents += addLW;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3888
                cont.numOfHWComponents += addHW;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3889
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3890
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3891
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3892
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3893
    final void decreaseComponentCount(Component c) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3894
        synchronized (getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3895
            if (!c.isDisplayable()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3896
                throw new IllegalStateException(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3897
                    "Peer does not exist while invoking the decreaseComponentCount() method"
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3898
                );
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3899
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3900
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3901
            int subHW = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3902
            int subLW = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3903
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3904
            if (c instanceof Container) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3905
                subLW = ((Container)c).numOfLWComponents;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3906
                subHW = ((Container)c).numOfHWComponents;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3907
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3908
            if (c.isLightweight()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3909
                subLW++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3910
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3911
                subHW++;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3912
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3913
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3914
            for (Container cont = this; cont != null; cont = cont.getContainer()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3915
                cont.numOfLWComponents -= subLW;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3916
                cont.numOfHWComponents -= subHW;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3917
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3918
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3919
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3920
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3921
    private int getTopmostComponentIndex() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3922
        checkTreeLock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3923
        if (getComponentCount() > 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3924
            return 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3925
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3926
        return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3927
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3928
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3929
    private int getBottommostComponentIndex() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3930
        checkTreeLock();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3931
        if (getComponentCount() > 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3932
            return getComponentCount() - 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3933
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3934
        return -1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3935
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3936
1978
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3937
    /*
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3938
     * This method is overriden to handle opaque children in non-opaque
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3939
     * containers.
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3940
     */
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3941
    @Override
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3942
    final Region getOpaqueShape() {
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3943
        checkTreeLock();
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3944
        if (isLightweight() && isNonOpaqueForMixing()
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3945
                && hasLightweightDescendants())
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3946
        {
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3947
            Region s = Region.EMPTY_REGION;
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3948
            for (int index = 0; index < getComponentCount(); index++) {
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3949
                Component c = getComponent(index);
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3950
                if (c.isLightweight() && c.isShowing()) {
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3951
                    s = s.getUnion(c.getOpaqueShape());
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3952
                }
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3953
            }
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3954
            return s.getIntersection(getNormalShape());
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3955
        }
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3956
        return super.getOpaqueShape();
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3957
    }
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3958
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3959
    final void recursiveSubtractAndApplyShape(Region shape) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3960
        recursiveSubtractAndApplyShape(shape, getTopmostComponentIndex(), getBottommostComponentIndex());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3961
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3962
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3963
    final void recursiveSubtractAndApplyShape(Region shape, int fromZorder) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3964
        recursiveSubtractAndApplyShape(shape, fromZorder, getBottommostComponentIndex());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3965
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3966
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3967
    final void recursiveSubtractAndApplyShape(Region shape, int fromZorder, int toZorder) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3968
        checkTreeLock();
3938
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
  3969
        if (mixingLog.isLoggable(PlatformLogger.FINE)) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3970
            mixingLog.fine("this = " + this +
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3971
                "; shape=" + shape + "; fromZ=" + fromZorder + "; toZ=" + toZorder);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3972
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3973
        if (fromZorder == -1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3974
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3975
        }
1978
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3976
        if (shape.isEmpty()) {
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3977
            return;
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3978
        }
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3979
        // An invalid container with not-null layout should be ignored
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3980
        // by the mixing code, the container will be validated later
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3981
        // and the mixing code will be executed later.
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3982
        if (getLayout() != null && !isValid()) {
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3983
            return;
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  3984
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3985
        for (int index = fromZorder; index <= toZorder; index++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3986
            Component comp = getComponent(index);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3987
            if (!comp.isLightweight()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3988
                comp.subtractAndApplyShape(shape);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3989
            } else if (comp instanceof Container &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3990
                    ((Container)comp).hasHeavyweightDescendants() && comp.isShowing()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3991
                ((Container)comp).recursiveSubtractAndApplyShape(shape);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3992
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3993
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3994
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3995
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3996
    final void recursiveApplyCurrentShape() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3997
        recursiveApplyCurrentShape(getTopmostComponentIndex(), getBottommostComponentIndex());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3998
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  3999
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4000
    final void recursiveApplyCurrentShape(int fromZorder) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4001
        recursiveApplyCurrentShape(fromZorder, getBottommostComponentIndex());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4002
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4003
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4004
    final void recursiveApplyCurrentShape(int fromZorder, int toZorder) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4005
        checkTreeLock();
3938
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
  4006
        if (mixingLog.isLoggable(PlatformLogger.FINE)) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4007
            mixingLog.fine("this = " + this +
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4008
                "; fromZ=" + fromZorder + "; toZ=" + toZorder);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4009
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4010
        if (fromZorder == -1) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4011
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4012
        }
1978
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4013
        // An invalid container with not-null layout should be ignored
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4014
        // by the mixing code, the container will be validated later
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4015
        // and the mixing code will be executed later.
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4016
        if (getLayout() != null && !isValid()) {
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4017
            return;
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4018
        }
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4019
        for (int index = fromZorder; index <= toZorder; index++) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4020
            Component comp = getComponent(index);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4021
            if (!comp.isLightweight()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4022
                comp.applyCurrentShape();
2644
63360b4ca6c4 6829858: JInternalFrame is not redrawing heavyweight children properly
anthony
parents: 2463
diff changeset
  4023
            }
63360b4ca6c4 6829858: JInternalFrame is not redrawing heavyweight children properly
anthony
parents: 2463
diff changeset
  4024
            if (comp instanceof Container &&
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4025
                    ((Container)comp).hasHeavyweightDescendants()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4026
                ((Container)comp).recursiveApplyCurrentShape();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4027
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4028
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4029
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4030
130
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4031
    private void recursiveShowHeavyweightChildren() {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4032
        if (!hasHeavyweightDescendants() || !isVisible()) {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4033
            return;
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4034
        }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4035
        for (int index = 0; index < getComponentCount(); index++) {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4036
            Component comp = getComponent(index);
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4037
            if (comp.isLightweight()) {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4038
                if  (comp instanceof Container) {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4039
                    ((Container)comp).recursiveShowHeavyweightChildren();
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4040
                }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4041
            } else {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4042
                if (comp.isVisible()) {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4043
                    ComponentPeer peer = comp.getPeer();
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4044
                    if (peer != null) {
1964
934568dfe859 6749920: Cleanup AWT peer interfaces
rkennke
parents: 1188
diff changeset
  4045
                        peer.setVisible(true);
130
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4046
                    }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4047
                }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4048
            }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4049
        }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4050
    }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4051
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4052
    private void recursiveHideHeavyweightChildren() {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4053
        if (!hasHeavyweightDescendants()) {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4054
            return;
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4055
        }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4056
        for (int index = 0; index < getComponentCount(); index++) {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4057
            Component comp = getComponent(index);
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4058
            if (comp.isLightweight()) {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4059
                if  (comp instanceof Container) {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4060
                    ((Container)comp).recursiveHideHeavyweightChildren();
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4061
                }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4062
            } else {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4063
                if (comp.isVisible()) {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4064
                    ComponentPeer peer = comp.getPeer();
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4065
                    if (peer != null) {
1964
934568dfe859 6749920: Cleanup AWT peer interfaces
rkennke
parents: 1188
diff changeset
  4066
                        peer.setVisible(false);
130
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4067
                    }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4068
                }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4069
            }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4070
        }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4071
    }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4072
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4073
    private void recursiveRelocateHeavyweightChildren(Point origin) {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4074
        for (int index = 0; index < getComponentCount(); index++) {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4075
            Component comp = getComponent(index);
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4076
            if (comp.isLightweight()) {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4077
                if  (comp instanceof Container &&
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4078
                        ((Container)comp).hasHeavyweightDescendants())
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4079
                {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4080
                    final Point newOrigin = new Point(origin);
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4081
                    newOrigin.translate(comp.getX(), comp.getY());
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4082
                    ((Container)comp).recursiveRelocateHeavyweightChildren(newOrigin);
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4083
                }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4084
            } else {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4085
                ComponentPeer peer = comp.getPeer();
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4086
                if (peer != null) {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4087
                    peer.setBounds(origin.x + comp.getX(), origin.y + comp.getY(),
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4088
                            comp.getWidth(), comp.getHeight(),
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4089
                            ComponentPeer.SET_LOCATION);
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4090
                }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4091
            }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4092
        }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4093
    }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4094
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4095
    /*
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4096
     * Consider the heavyweight container hides or shows the HW descendants
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4097
     * automatically. Therefore we care of LW containers' visibility only.
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4098
     */
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4099
    private boolean isRecursivelyVisibleUpToHeavyweightContainer() {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4100
        if (!isLightweight()) {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4101
            return true;
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4102
        }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4103
        return isVisible() && (getContainer() == null ||
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4104
             getContainer().isRecursivelyVisibleUpToHeavyweightContainer());
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4105
    }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4106
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4107
    @Override
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4108
    void mixOnShowing() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4109
        synchronized (getTreeLock()) {
3938
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
  4110
            if (mixingLog.isLoggable(PlatformLogger.FINE)) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4111
                mixingLog.fine("this = " + this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4112
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4113
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4114
            boolean isLightweight = isLightweight();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4115
130
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4116
            if (isLightweight && isRecursivelyVisibleUpToHeavyweightContainer()) {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4117
                recursiveShowHeavyweightChildren();
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4118
            }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4119
3971
067e6580a577 6862611: Reg testcase closed/java/awt/Component/NativeInLightShow/NativeInLightShow.html fails
anthony
parents: 3966
diff changeset
  4120
            if (!isMixingNeeded()) {
067e6580a577 6862611: Reg testcase closed/java/awt/Component/NativeInLightShow/NativeInLightShow.html fails
anthony
parents: 3966
diff changeset
  4121
                return;
067e6580a577 6862611: Reg testcase closed/java/awt/Component/NativeInLightShow/NativeInLightShow.html fails
anthony
parents: 3966
diff changeset
  4122
            }
067e6580a577 6862611: Reg testcase closed/java/awt/Component/NativeInLightShow/NativeInLightShow.html fails
anthony
parents: 3966
diff changeset
  4123
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4124
            if (!isLightweight || (isLightweight && hasHeavyweightDescendants())) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4125
                recursiveApplyCurrentShape();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4126
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4127
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4128
            super.mixOnShowing();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4129
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4130
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4131
130
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4132
    @Override
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4133
    void mixOnHiding(boolean isLightweight) {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4134
        synchronized (getTreeLock()) {
3938
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
  4135
            if (mixingLog.isLoggable(PlatformLogger.FINE)) {
130
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4136
                mixingLog.fine("this = " + this +
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4137
                        "; isLightweight=" + isLightweight);
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4138
            }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4139
            if (isLightweight) {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4140
                recursiveHideHeavyweightChildren();
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4141
            }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4142
            super.mixOnHiding(isLightweight);
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4143
        }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4144
    }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4145
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4146
    @Override
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4147
    void mixOnReshaping() {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4148
        synchronized (getTreeLock()) {
3938
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
  4149
            if (mixingLog.isLoggable(PlatformLogger.FINE)) {
130
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4150
                mixingLog.fine("this = " + this);
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4151
            }
1978
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4152
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4153
            boolean isMixingNeeded = isMixingNeeded();
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4154
130
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4155
            if (isLightweight() && hasHeavyweightDescendants()) {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4156
                final Point origin = new Point(getX(), getY());
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4157
                for (Container cont = getContainer();
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4158
                        cont != null && cont.isLightweight();
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4159
                        cont = cont.getContainer())
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4160
                {
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4161
                    origin.translate(cont.getX(), cont.getY());
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4162
                }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4163
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4164
                recursiveRelocateHeavyweightChildren(origin);
1978
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4165
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4166
                if (!isMixingNeeded) {
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4167
                    return;
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4168
                }
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4169
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4170
                recursiveApplyCurrentShape();
130
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4171
            }
1978
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4172
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4173
            if (!isMixingNeeded) {
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4174
                return;
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4175
            }
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4176
130
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4177
            super.mixOnReshaping();
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4178
        }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4179
    }
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4180
11eb29307cfb 4993545: NativeInLightFixer adds asynchronousity
anthony
parents: 125
diff changeset
  4181
    @Override
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4182
    void mixOnZOrderChanging(int oldZorder, int newZorder) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4183
        synchronized (getTreeLock()) {
3938
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
  4184
            if (mixingLog.isLoggable(PlatformLogger.FINE)) {
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4185
                mixingLog.fine("this = " + this +
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4186
                    "; oldZ=" + oldZorder + "; newZ=" + newZorder);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4187
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4188
1978
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4189
            if (!isMixingNeeded()) {
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4190
                return;
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4191
            }
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4192
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4193
            boolean becameHigher = newZorder < oldZorder;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4194
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4195
            if (becameHigher && isLightweight() && hasHeavyweightDescendants()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4196
                recursiveApplyCurrentShape();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4197
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4198
            super.mixOnZOrderChanging(oldZorder, newZorder);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4199
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4200
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4201
1183
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  4202
    @Override
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  4203
    void mixOnValidating() {
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  4204
        synchronized (getTreeLock()) {
3938
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
  4205
            if (mixingLog.isLoggable(PlatformLogger.FINE)) {
1183
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  4206
                mixingLog.fine("this = " + this);
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  4207
            }
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  4208
1978
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4209
            if (!isMixingNeeded()) {
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4210
                return;
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4211
            }
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4212
1183
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  4213
            if (hasHeavyweightDescendants()) {
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  4214
                recursiveApplyCurrentShape();
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  4215
            }
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  4216
1978
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4217
            if (isLightweight() && isNonOpaqueForMixing()) {
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4218
                subtractAndApplyShapeBelowMe();
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4219
            }
8b981ce05cd0 6797195: Forward-port enhancements for hw/lw mixing from 6u12 to 7
anthony
parents: 1964
diff changeset
  4220
1183
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  4221
            super.mixOnValidating();
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  4222
        }
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  4223
    }
80d6aafba03a 6682046: Mixing code does not always recalculate shapes correctly when resizing components
anthony
parents: 1172
diff changeset
  4224
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4225
    // ****************** END OF MIXING CODE ********************************
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4226
}
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4227
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4228
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4229
/**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4230
 * Class to manage the dispatching of MouseEvents to the lightweight descendants
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4231
 * and SunDropTargetEvents to both lightweight and heavyweight descendants
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4232
 * contained by a native container.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4233
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4234
 * NOTE: the class name is not appropriate anymore, but we cannot change it
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4235
 * because we must keep serialization compatibility.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4236
 *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4237
 * @author Timothy Prinzing
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4238
 */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4239
class LightweightDispatcher implements java.io.Serializable, AWTEventListener {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4240
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4241
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4242
     * JDK 1.1 serialVersionUID
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4243
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4244
    private static final long serialVersionUID = 5184291520170872969L;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4245
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4246
     * Our own mouse event for when we're dragged over from another hw
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4247
     * container
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4248
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4249
    private static final int  LWD_MOUSE_DRAGGED_OVER = 1500;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4250
3938
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
  4251
    private static final PlatformLogger eventLog = PlatformLogger.getLogger("java.awt.event.LightweightDispatcher");
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4252
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4253
    LightweightDispatcher(Container nativeContainer) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4254
        this.nativeContainer = nativeContainer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4255
        mouseEventTarget = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4256
        eventMask = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4257
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4258
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4259
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4260
     * Clean up any resources allocated when dispatcher was created;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4261
     * should be called from Container.removeNotify
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4262
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4263
    void dispose() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4264
        //System.out.println("Disposing lw dispatcher");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4265
        stopListeningForOtherDrags();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4266
        mouseEventTarget = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4267
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4268
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4269
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4270
     * Enables events to subcomponents.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4271
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4272
    void enableEvents(long events) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4273
        eventMask |= events;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4274
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4275
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4276
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4277
     * Dispatches an event to a sub-component if necessary, and
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4278
     * returns whether or not the event was forwarded to a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4279
     * sub-component.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4280
     *
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4281
     * @param e the event
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4282
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4283
    boolean dispatchEvent(AWTEvent e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4284
        boolean ret = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4285
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4286
        /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4287
         * Fix for BugTraq Id 4389284.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4288
         * Dispatch SunDropTargetEvents regardless of eventMask value.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4289
         * Do not update cursor on dispatching SunDropTargetEvents.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4290
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4291
        if (e instanceof SunDropTargetEvent) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4292
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4293
            SunDropTargetEvent sdde = (SunDropTargetEvent) e;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4294
            ret = processDropTargetEvent(sdde);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4295
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4296
        } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4297
            if (e instanceof MouseEvent && (eventMask & MOUSE_MASK) != 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4298
                MouseEvent me = (MouseEvent) e;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4299
                ret = processMouseEvent(me);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4300
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4301
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4302
            if (e.getID() == MouseEvent.MOUSE_MOVED) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4303
                nativeContainer.updateCursorImmediately();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4304
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4305
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4306
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4307
        return ret;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4308
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4309
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4310
    /* This method effectively returns whether or not a mouse button was down
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4311
     * just BEFORE the event happened.  A better method name might be
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4312
     * wasAMouseButtonDownBeforeThisEvent().
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4313
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4314
    private boolean isMouseGrab(MouseEvent e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4315
        int modifiers = e.getModifiersEx();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4316
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4317
        if(e.getID() == MouseEvent.MOUSE_PRESSED
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4318
            || e.getID() == MouseEvent.MOUSE_RELEASED)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4319
        {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4320
            switch (e.getButton()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4321
            case MouseEvent.BUTTON1:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4322
                modifiers ^= InputEvent.BUTTON1_DOWN_MASK;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4323
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4324
            case MouseEvent.BUTTON2:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4325
                modifiers ^= InputEvent.BUTTON2_DOWN_MASK;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4326
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4327
            case MouseEvent.BUTTON3:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4328
                modifiers ^= InputEvent.BUTTON3_DOWN_MASK;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4329
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4330
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4331
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4332
        /* modifiers now as just before event */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4333
        return ((modifiers & (InputEvent.BUTTON1_DOWN_MASK
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4334
                              | InputEvent.BUTTON2_DOWN_MASK
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4335
                              | InputEvent.BUTTON3_DOWN_MASK)) != 0);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4336
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4337
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4338
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4339
     * This method attempts to distribute a mouse event to a lightweight
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4340
     * component.  It tries to avoid doing any unnecessary probes down
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4341
     * into the component tree to minimize the overhead of determining
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4342
     * where to route the event, since mouse movement events tend to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4343
     * come in large and frequent amounts.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4344
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4345
    private boolean processMouseEvent(MouseEvent e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4346
        int id = e.getID();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4347
        Component mouseOver =   // sensitive to mouse events
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4348
            nativeContainer.getMouseEventTarget(e.getX(), e.getY(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4349
                                                Container.INCLUDE_SELF);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4350
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4351
        trackMouseEnterExit(mouseOver, e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4352
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4353
    // 4508327 : MOUSE_CLICKED should only go to the recipient of
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4354
    // the accompanying MOUSE_PRESSED, so don't reset mouseEventTarget on a
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4355
    // MOUSE_CLICKED.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4356
    if (!isMouseGrab(e) && id != MouseEvent.MOUSE_CLICKED) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4357
            mouseEventTarget = (mouseOver != nativeContainer) ? mouseOver: null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4358
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4359
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4360
        if (mouseEventTarget != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4361
            switch (id) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4362
            case MouseEvent.MOUSE_ENTERED:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4363
            case MouseEvent.MOUSE_EXITED:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4364
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4365
            case MouseEvent.MOUSE_PRESSED:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4366
                retargetMouseEvent(mouseEventTarget, id, e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4367
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4368
        case MouseEvent.MOUSE_RELEASED:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4369
            retargetMouseEvent(mouseEventTarget, id, e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4370
        break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4371
        case MouseEvent.MOUSE_CLICKED:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4372
        // 4508327: MOUSE_CLICKED should never be dispatched to a Component
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4373
        // other than that which received the MOUSE_PRESSED event.  If the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4374
        // mouse is now over a different Component, don't dispatch the event.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4375
        // The previous fix for a similar problem was associated with bug
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4376
        // 4155217.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4377
        if (mouseOver == mouseEventTarget) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4378
            retargetMouseEvent(mouseOver, id, e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4379
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4380
        break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4381
            case MouseEvent.MOUSE_MOVED:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4382
                retargetMouseEvent(mouseEventTarget, id, e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4383
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4384
        case MouseEvent.MOUSE_DRAGGED:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4385
            if (isMouseGrab(e)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4386
                retargetMouseEvent(mouseEventTarget, id, e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4387
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4388
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4389
        case MouseEvent.MOUSE_WHEEL:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4390
            // This may send it somewhere that doesn't have MouseWheelEvents
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4391
            // enabled.  In this case, Component.dispatchEventImpl() will
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4392
            // retarget the event to a parent that DOES have the events enabled.
3938
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
  4393
            if (eventLog.isLoggable(PlatformLogger.FINEST) && (mouseOver != null)) {
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
  4394
                eventLog.finest("retargeting mouse wheel to " +
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
  4395
                                mouseOver.getName() + ", " +
ef327bd847c0 6879044: Eliminate the dependency on logging from the AWT/2D/Swing classes
mchung
parents: 2805
diff changeset
  4396
                                mouseOver.getClass());
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4397
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4398
            retargetMouseEvent(mouseOver, id, e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4399
        break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4400
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4401
            e.consume();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4402
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4403
    return e.isConsumed();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4404
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4405
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4406
    private boolean processDropTargetEvent(SunDropTargetEvent e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4407
        int id = e.getID();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4408
        int x = e.getX();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4409
        int y = e.getY();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4410
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4411
        /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4412
         * Fix for BugTraq ID 4395290.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4413
         * It is possible that SunDropTargetEvent's Point is outside of the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4414
         * native container bounds. In this case we truncate coordinates.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4415
         */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4416
        if (!nativeContainer.contains(x, y)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4417
            final Dimension d = nativeContainer.getSize();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4418
            if (d.width <= x) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4419
                x = d.width - 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4420
            } else if (x < 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4421
                x = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4422
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4423
            if (d.height <= y) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4424
                y = d.height - 1;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4425
            } else if (y < 0) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4426
                y = 0;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4427
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4428
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4429
        Component mouseOver =   // not necessarily sensitive to mouse events
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4430
            nativeContainer.getDropTargetEventTarget(x, y,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4431
                                                     Container.INCLUDE_SELF);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4432
        trackMouseEnterExit(mouseOver, e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4433
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4434
        if (mouseOver != nativeContainer && mouseOver != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4435
            switch (id) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4436
            case SunDropTargetEvent.MOUSE_ENTERED:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4437
            case SunDropTargetEvent.MOUSE_EXITED:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4438
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4439
            default:
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4440
                retargetMouseEvent(mouseOver, id, e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4441
                e.consume();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4442
                break;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4443
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4444
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4445
        return e.isConsumed();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4446
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4447
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4448
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4449
     * Generates enter/exit events as mouse moves over lw components
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4450
     * @param targetOver        Target mouse is over (including native container)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4451
     * @param e                 Mouse event in native container
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4452
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4453
    private void trackMouseEnterExit(Component targetOver, MouseEvent e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4454
        Component       targetEnter = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4455
        int             id = e.getID();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4456
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4457
        if (e instanceof SunDropTargetEvent &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4458
            id == MouseEvent.MOUSE_ENTERED &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4459
            isMouseInNativeContainer == true) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4460
            // This can happen if a lightweight component which initiated the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4461
            // drag has an associated drop target. MOUSE_ENTERED comes when the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4462
            // mouse is in the native container already. To propagate this event
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4463
            // properly we should null out targetLastEntered.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4464
            targetLastEntered = null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4465
        } else if ( id != MouseEvent.MOUSE_EXITED &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4466
             id != MouseEvent.MOUSE_DRAGGED &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4467
             id != LWD_MOUSE_DRAGGED_OVER &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4468
             isMouseInNativeContainer == false ) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4469
            // any event but an exit or drag means we're in the native container
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4470
            isMouseInNativeContainer = true;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4471
            startListeningForOtherDrags();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4472
        } else if ( id == MouseEvent.MOUSE_EXITED ) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4473
            isMouseInNativeContainer = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4474
            stopListeningForOtherDrags();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4475
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4476
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4477
        if (isMouseInNativeContainer) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4478
            targetEnter = targetOver;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4479
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4480
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4481
        if (targetLastEntered == targetEnter) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4482
                return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4483
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4484
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4485
        if (targetLastEntered != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4486
            retargetMouseEvent(targetLastEntered, MouseEvent.MOUSE_EXITED, e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4487
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4488
        if (id == MouseEvent.MOUSE_EXITED) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4489
            // consume native exit event if we generate one
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4490
            e.consume();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4491
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4492
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4493
        if (targetEnter != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4494
            retargetMouseEvent(targetEnter, MouseEvent.MOUSE_ENTERED, e);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4495
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4496
        if (id == MouseEvent.MOUSE_ENTERED) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4497
            // consume native enter event if we generate one
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4498
            e.consume();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4499
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4500
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4501
        targetLastEntered = targetEnter;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4502
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4503
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4504
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4505
     * Listens to global mouse drag events so even drags originating
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4506
     * from other heavyweight containers will generate enter/exit
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4507
     * events in this container
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4508
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4509
    private void startListeningForOtherDrags() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4510
        //System.out.println("Adding AWTEventListener");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4511
        java.security.AccessController.doPrivileged(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4512
            new java.security.PrivilegedAction() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4513
                public Object run() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4514
                    nativeContainer.getToolkit().addAWTEventListener(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4515
                        LightweightDispatcher.this,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4516
                        AWTEvent.MOUSE_EVENT_MASK |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4517
                        AWTEvent.MOUSE_MOTION_EVENT_MASK);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4518
                    return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4519
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4520
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4521
        );
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4522
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4523
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4524
    private void stopListeningForOtherDrags() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4525
        //System.out.println("Removing AWTEventListener");
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4526
        java.security.AccessController.doPrivileged(
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4527
            new java.security.PrivilegedAction() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4528
                public Object run() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4529
                    nativeContainer.getToolkit().removeAWTEventListener(LightweightDispatcher.this);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4530
                    return null;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4531
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4532
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4533
        );
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4534
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4535
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4536
    /*
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4537
     * (Implementation of AWTEventListener)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4538
     * Listen for drag events posted in other hw components so we can
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4539
     * track enter/exit regardless of where a drag originated
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4540
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4541
    public void eventDispatched(AWTEvent e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4542
        boolean isForeignDrag = (e instanceof MouseEvent) &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4543
                                !(e instanceof SunDropTargetEvent) &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4544
                                (e.id == MouseEvent.MOUSE_DRAGGED) &&
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4545
                                (e.getSource() != nativeContainer);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4546
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4547
        if (!isForeignDrag) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4548
            // only interested in drags from other hw components
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4549
            return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4550
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4551
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4552
        MouseEvent      srcEvent = (MouseEvent)e;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4553
        MouseEvent      me;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4554
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4555
        synchronized (nativeContainer.getTreeLock()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4556
            Component srcComponent = srcEvent.getComponent();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4557
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4558
            // component may have disappeared since drag event posted
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4559
            // (i.e. Swing hierarchical menus)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4560
            if ( !srcComponent.isShowing() ) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4561
                return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4562
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4563
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4564
            // see 5083555
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4565
            // check if srcComponent is in any modal blocked window
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4566
            Component c = nativeContainer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4567
            while ((c != null) && !(c instanceof Window)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4568
                c = c.getParent_NoClientCode();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4569
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4570
            if ((c == null) || ((Window)c).isModalBlocked()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4571
                return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4572
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4573
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4574
            //
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4575
            // create an internal 'dragged-over' event indicating
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4576
            // we are being dragged over from another hw component
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4577
            //
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4578
            me = new MouseEvent(nativeContainer,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4579
                               LWD_MOUSE_DRAGGED_OVER,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4580
                               srcEvent.getWhen(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4581
                               srcEvent.getModifiersEx() | srcEvent.getModifiers(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4582
                               srcEvent.getX(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4583
                               srcEvent.getY(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4584
                               srcEvent.getXOnScreen(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4585
                               srcEvent.getYOnScreen(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4586
                               srcEvent.getClickCount(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4587
                               srcEvent.isPopupTrigger(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4588
                               srcEvent.getButton());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4589
            ((AWTEvent)srcEvent).copyPrivateDataInto(me);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4590
            // translate coordinates to this native container
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4591
            final Point ptSrcOrigin = srcComponent.getLocationOnScreen();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4592
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4593
            if (AppContext.getAppContext() != nativeContainer.appContext) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4594
                final MouseEvent mouseEvent = me;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4595
                Runnable r = new Runnable() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4596
                        public void run() {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4597
                            if (!nativeContainer.isShowing() ) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4598
                                return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4599
                            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4600
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4601
                            Point       ptDstOrigin = nativeContainer.getLocationOnScreen();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4602
                            mouseEvent.translatePoint(ptSrcOrigin.x - ptDstOrigin.x,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4603
                                              ptSrcOrigin.y - ptDstOrigin.y );
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4604
                            Component targetOver =
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4605
                                nativeContainer.getMouseEventTarget(mouseEvent.getX(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4606
                                                                    mouseEvent.getY(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4607
                                                                    Container.INCLUDE_SELF);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4608
                            trackMouseEnterExit(targetOver, mouseEvent);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4609
                        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4610
                    };
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4611
                SunToolkit.executeOnEventHandlerThread(nativeContainer, r);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4612
                return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4613
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4614
                if (!nativeContainer.isShowing() ) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4615
                    return;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4616
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4617
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4618
                Point   ptDstOrigin = nativeContainer.getLocationOnScreen();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4619
                me.translatePoint( ptSrcOrigin.x - ptDstOrigin.x, ptSrcOrigin.y - ptDstOrigin.y );
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4620
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4621
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4622
        //System.out.println("Track event: " + me);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4623
        // feed the 'dragged-over' event directly to the enter/exit
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4624
        // code (not a real event so don't pass it to dispatchEvent)
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4625
        Component targetOver =
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4626
            nativeContainer.getMouseEventTarget(me.getX(), me.getY(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4627
                                                Container.INCLUDE_SELF);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4628
        trackMouseEnterExit(targetOver, me);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4629
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4630
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4631
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4632
     * Sends a mouse event to the current mouse event recipient using
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4633
     * the given event (sent to the windowed host) as a srcEvent.  If
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4634
     * the mouse event target is still in the component tree, the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4635
     * coordinates of the event are translated to those of the target.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4636
     * If the target has been removed, we don't bother to send the
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4637
     * message.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4638
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4639
    void retargetMouseEvent(Component target, int id, MouseEvent e) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4640
        if (target == null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4641
            return; // mouse is over another hw component or target is disabled
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4642
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4643
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4644
        int x = e.getX(), y = e.getY();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4645
        Component component;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4646
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4647
        for(component = target;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4648
            component != null && component != nativeContainer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4649
            component = component.getParent()) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4650
            x -= component.x;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4651
            y -= component.y;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4652
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4653
        MouseEvent retargeted;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4654
        if (component != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4655
            if (e instanceof SunDropTargetEvent) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4656
                retargeted = new SunDropTargetEvent(target,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4657
                                                    id,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4658
                                                    x,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4659
                                                    y,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4660
                                                    ((SunDropTargetEvent)e).getDispatcher());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4661
            } else if (id == MouseEvent.MOUSE_WHEEL) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4662
                retargeted = new MouseWheelEvent(target,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4663
                                      id,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4664
                                       e.getWhen(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4665
                                       e.getModifiersEx() | e.getModifiers(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4666
                                       x,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4667
                                       y,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4668
                                       e.getXOnScreen(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4669
                                       e.getYOnScreen(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4670
                                       e.getClickCount(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4671
                                       e.isPopupTrigger(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4672
                                       ((MouseWheelEvent)e).getScrollType(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4673
                                       ((MouseWheelEvent)e).getScrollAmount(),
121
c43b2dfab9ac 6524352: support for high-resolution mouse wheel
dcherepanov
parents: 2
diff changeset
  4674
                                       ((MouseWheelEvent)e).getWheelRotation(),
c43b2dfab9ac 6524352: support for high-resolution mouse wheel
dcherepanov
parents: 2
diff changeset
  4675
                                       ((MouseWheelEvent)e).getPreciseWheelRotation());
2
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4676
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4677
            else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4678
                retargeted = new MouseEvent(target,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4679
                                            id,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4680
                                            e.getWhen(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4681
                                            e.getModifiersEx() | e.getModifiers(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4682
                                            x,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4683
                                            y,
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4684
                                            e.getXOnScreen(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4685
                                            e.getYOnScreen(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4686
                                            e.getClickCount(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4687
                                            e.isPopupTrigger(),
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4688
                                            e.getButton());
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4689
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4690
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4691
            ((AWTEvent)e).copyPrivateDataInto(retargeted);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4692
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4693
            if (target == nativeContainer) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4694
                // avoid recursively calling LightweightDispatcher...
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4695
                ((Container)target).dispatchEventToSelf(retargeted);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4696
            } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4697
                assert AppContext.getAppContext() == target.appContext;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4698
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4699
                if (nativeContainer.modalComp != null) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4700
                    if (((Container)nativeContainer.modalComp).isAncestorOf(target)) {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4701
                        target.dispatchEvent(retargeted);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4702
                    } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4703
                        e.consume();
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4704
                    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4705
                } else {
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4706
                    target.dispatchEvent(retargeted);
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4707
                }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4708
            }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4709
        }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4710
    }
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4711
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4712
    // --- member variables -------------------------------
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4713
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4714
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4715
     * The windowed container that might be hosting events for
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4716
     * subcomponents.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4717
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4718
    private Container nativeContainer;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4719
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4720
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4721
     * This variable is not used, but kept for serialization compatibility
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4722
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4723
    private Component focus;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4724
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4725
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4726
     * The current subcomponent being hosted by this windowed
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4727
     * component that has events being forwarded to it.  If this
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4728
     * is null, there are currently no events being forwarded to
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4729
     * a subcomponent.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4730
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4731
    private transient Component mouseEventTarget;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4732
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4733
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4734
     * The last component entered
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4735
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4736
    private transient Component targetLastEntered;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4737
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4738
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4739
     * Is the mouse over the native container
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4740
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4741
    private transient boolean isMouseInNativeContainer = false;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4742
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4743
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4744
     * This variable is not used, but kept for serialization compatibility
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4745
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4746
    private Cursor nativeCursor;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4747
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4748
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4749
     * The event mask for contained lightweight components.  Lightweight
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4750
     * components need a windowed container to host window-related
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4751
     * events.  This separate mask indicates events that have been
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4752
     * requested by contained lightweight components without effecting
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4753
     * the mask of the windowed component itself.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4754
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4755
    private long eventMask;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4756
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4757
    /**
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4758
     * The kind of events routed to lightweight components from windowed
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4759
     * hosts.
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4760
     */
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4761
    private static final long PROXY_EVENT_MASK =
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4762
        AWTEvent.FOCUS_EVENT_MASK |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4763
        AWTEvent.KEY_EVENT_MASK |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4764
        AWTEvent.MOUSE_EVENT_MASK |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4765
        AWTEvent.MOUSE_MOTION_EVENT_MASK |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4766
        AWTEvent.MOUSE_WHEEL_EVENT_MASK;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4767
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4768
    private static final long MOUSE_MASK =
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4769
        AWTEvent.MOUSE_EVENT_MASK |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4770
        AWTEvent.MOUSE_MOTION_EVENT_MASK |
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4771
        AWTEvent.MOUSE_WHEEL_EVENT_MASK;
90ce3da70b43 Initial load
duke
parents:
diff changeset
  4772
}