private static final PlatformLogger log = PlatformLogger.getLogger("java.awt.Container");

private static final PlatformLogger eventLog = PlatformLogger.getLogger("java.awt.event.Container");

private static final Component[] EMPTY_ARRAY = new Component[0];

/**

private java.util.List<Component> component = new java.util.ArrayList<Component>();

/**

LayoutManager layoutMgr;

/**

private LightweightDispatcher dispatcher;

/**

private transient FocusTraversalPolicy focusTraversalPolicy;

/**

private boolean focusCycleRoot = false;

/**

private boolean focusTraversalPolicyProvider;

// keeps track of the threads that are printing this component

private transient Set<Thread> printingThreads;

// True if there is at least one thread that's printing this component

private transient boolean printing = false;

transient ContainerListener containerListener;

/* HierarchyListener and HierarchyBoundsListener support */

transient int listeningChildren;

transient int listeningBoundsChildren;

transient int descendantsCount;

/* Non-opaque window support -- see Window.setLayersOpaque */

transient Color preserveBackgroundColor = null;

/**

private static final long serialVersionUID = 4613797578919906343L;

/**

static final boolean INCLUDE_SELF = true;

/**

static final boolean SEARCH_HEAVYWEIGHTS = true;

/*

private transient int numOfHWComponents = 0;

private transient int numOfLWComponents = 0;

private static final PlatformLogger mixingLog = PlatformLogger.getLogger("java.awt.mixing.Container");

/**

private static final ObjectStreamField[] serialPersistentFields = {

new ObjectStreamField("ncomponents", Integer.TYPE),

new ObjectStreamField("component", Component[].class),

new ObjectStreamField("layoutMgr", LayoutManager.class),

new ObjectStreamField("dispatcher", LightweightDispatcher.class),

new ObjectStreamField("maxSize", Dimension.class),

new ObjectStreamField("focusCycleRoot", Boolean.TYPE),

new ObjectStreamField("containerSerializedDataVersion", Integer.TYPE),

new ObjectStreamField("focusTraversalPolicyProvider", Boolean.TYPE),

};

static {

/* ensure that the necessary native libraries are loaded */

Toolkit.loadLibraries();

if (!GraphicsEnvironment.isHeadless()) {

initIDs();

}

AWTAccessor.setContainerAccessor(new AWTAccessor.ContainerAccessor() {

@Override

public void validateUnconditionally(Container cont) {

cont.validateUnconditionally();

}

@Override

public Component findComponentAt(Container cont, int x, int y,

boolean ignoreEnabled) {

return cont.findComponentAt(x, y, ignoreEnabled);

}

});

}

/**

private static native void initIDs();

/**

public Container() {

}

@SuppressWarnings({"unchecked","rawtypes"})

void initializeFocusTraversalKeys() {

focusTraversalKeys = new Set[4];

}

/**

public int getComponentCount() {

return countComponents();

}

/**

@Deprecated

public int countComponents() {

// This method is not synchronized under AWT tree lock.

// Instead, the calling code is responsible for the

// synchronization. See 6784816 for details.

return component.size();

}

/**

public Component getComponent(int n) {

// This method is not synchronized under AWT tree lock.

// Instead, the calling code is responsible for the

// synchronization. See 6784816 for details.

try {

return component.get(n);

} catch (IndexOutOfBoundsException z) {

throw new ArrayIndexOutOfBoundsException("No such child: " + n);

}

}

/**

public Component[] getComponents() {

// This method is not synchronized under AWT tree lock.

// Instead, the calling code is responsible for the

// synchronization. See 6784816 for details.

return getComponents_NoClientCode();

}

// NOTE: This method may be called by privileged threads.

// This functionality is implemented in a package-private method

// to insure that it cannot be overridden by client subclasses.

// DO NOT INVOKE CLIENT CODE ON THIS THREAD!

final Component[] getComponents_NoClientCode() {

return component.toArray(EMPTY_ARRAY);

}

/*

Component[] getComponentsSync() {

synchronized (getTreeLock()) {

return getComponents();

}

}

/**

public Insets getInsets() {

return insets();

}

/**

@Deprecated

public Insets insets() {

ComponentPeer peer = this.peer;

if (peer instanceof ContainerPeer) {

ContainerPeer cpeer = (ContainerPeer)peer;

return (Insets)cpeer.getInsets().clone();

}

return new Insets(0, 0, 0, 0);

}

/**

public Component add(Component comp) {

addImpl(comp, null, -1);

return comp;

}

/**

public Component add(String name, Component comp) {

addImpl(comp, name, -1);

return comp;

}

/**

public Component add(Component comp, int index) {

addImpl(comp, null, index);

return comp;

}

/**

private void checkAddToSelf(Component comp){

if (comp instanceof Container) {

for (Container cn = this; cn != null; cn=cn.parent) {

if (cn == comp) {

throw new IllegalArgumentException("adding container's parent to itself");

}

}

}

}

/**

private void checkNotAWindow(Component comp){

if (comp instanceof Window) {

throw new IllegalArgumentException("adding a window to a container");

}

}

/**

private void checkAdding(Component comp, int index) {

checkTreeLock();

GraphicsConfiguration thisGC = getGraphicsConfiguration();

if (index > component.size() || index < 0) {

throw new IllegalArgumentException("illegal component position");

}

if (comp.parent == this) {

if (index == component.size()) {

throw new IllegalArgumentException("illegal component position " +

index + " should be less then " + component.size());

}

}

checkAddToSelf(comp);

checkNotAWindow(comp);

Window thisTopLevel = getContainingWindow();

Window compTopLevel = comp.getContainingWindow();

if (thisTopLevel != compTopLevel) {

throw new IllegalArgumentException("component and container should be in the same top-level window");

}

if (thisGC != null) {

comp.checkGD(thisGC.getDevice().getIDstring());

}

}

/**

private boolean removeDelicately(Component comp, Container newParent, int newIndex) {

checkTreeLock();

int index = getComponentZOrder(comp);

boolean needRemoveNotify = isRemoveNotifyNeeded(comp, this, newParent);

if (needRemoveNotify) {

comp.removeNotify();

}

if (newParent != this) {

if (layoutMgr != null) {

layoutMgr.removeLayoutComponent(comp);

}

adjustListeningChildren(AWTEvent.HIERARCHY_EVENT_MASK,

-comp.numListening(AWTEvent.HIERARCHY_EVENT_MASK));

adjustListeningChildren(AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK,

-comp.numListening(AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK));

adjustDescendants(-(comp.countHierarchyMembers()));

comp.parent = null;

if (needRemoveNotify) {

comp.setGraphicsConfiguration(null);

}

component.remove(index);

invalidateIfValid();

} else {

// We should remove component and then

// add it by the newIndex without newIndex decrement if even we shift components to the left

// after remove. Consult the rules below:

// 2->4: 012345 -> 013425, 2->5: 012345 -> 013452

// 4->2: 012345 -> 014235

component.remove(index);

component.add(newIndex, comp);

}

if (comp.parent == null) { // was actually removed

if (containerListener != null ||

(eventMask & AWTEvent.CONTAINER_EVENT_MASK) != 0 ||

Toolkit.enabledOnToolkit(AWTEvent.CONTAINER_EVENT_MASK)) {

ContainerEvent e = new ContainerEvent(this,

ContainerEvent.COMPONENT_REMOVED,

comp);

dispatchEvent(e);

}

comp.createHierarchyEvents(HierarchyEvent.HIERARCHY_CHANGED, comp,

this, HierarchyEvent.PARENT_CHANGED,

Toolkit.enabledOnToolkit(AWTEvent.HIERARCHY_EVENT_MASK));

if (peer != null && layoutMgr == null && isVisible()) {

updateCursorImmediately();

}

}

return needRemoveNotify;

}

/**

boolean canContainFocusOwner(Component focusOwnerCandidate) {

if (!(isEnabled() && isDisplayable()

&& isVisible() && isFocusable()))

{

return false;

}

if (isFocusCycleRoot()) {

FocusTraversalPolicy policy = getFocusTraversalPolicy();

if (policy instanceof DefaultFocusTraversalPolicy) {

if (!((DefaultFocusTraversalPolicy)policy).accept(focusOwnerCandidate)) {

return false;

}

}

}

synchronized(getTreeLock()) {

if (parent != null) {

return parent.canContainFocusOwner(focusOwnerCandidate);

}

}

return true;

}

/**

final boolean hasHeavyweightDescendants() {

checkTreeLock();

return numOfHWComponents > 0;

}

/**

final boolean hasLightweightDescendants() {

checkTreeLock();

return numOfLWComponents > 0;

}

/**

Container getHeavyweightContainer() {

checkTreeLock();

if (peer != null && !(peer instanceof LightweightPeer)) {

return this;

} else {

return getNativeContainer();

}

}

/**

private static boolean isRemoveNotifyNeeded(Component comp, Container oldContainer, Container newContainer) {

if (oldContainer == null) { // Component didn't have parent - no removeNotify

return false;

}

if (comp.peer == null) { // Component didn't have peer - no removeNotify

return false;

}

if (newContainer.peer == null) {

// Component has peer but new Container doesn't - call removeNotify

return true;

}

// If component is lightweight non-Container or lightweight Container with all but heavyweight

// children there is no need to call remove notify

if (comp.isLightweight()) {

boolean isContainer = comp instanceof Container;

if (!isContainer || (isContainer && !((Container)comp).hasHeavyweightDescendants())) {

return false;

}

}

// If this point is reached, then the comp is either a HW or a LW container with HW descendants.

// All three components have peers, check for peer change

Container newNativeContainer = oldContainer.getHeavyweightContainer();

Container oldNativeContainer = newContainer.getHeavyweightContainer();

if (newNativeContainer != oldNativeContainer) {

// Native containers change - check whether or not current platform supports

// changing of widget hierarchy on native level without recreation.

// The current implementation forbids reparenting of LW containers with HW descendants

// into another native container w/o destroying the peers. Actually such an operation

// is quite rare. If we ever need to save the peers, we'll have to slightly change the

// addDelicately() method in order to handle such LW containers recursively, reparenting

// each HW descendant independently.

return !comp.peer.isReparentSupported();

} else {

return false;

}

}

/**

public void setComponentZOrder(Component comp, int index) {

synchronized (getTreeLock()) {

// Store parent because remove will clear it

Container curParent = comp.parent;

int oldZindex = getComponentZOrder(comp);

if (curParent == this && index == oldZindex) {

return;

}

checkAdding(comp, index);

boolean peerRecreated = (curParent != null) ?

curParent.removeDelicately(comp, this, index) : false;

addDelicately(comp, curParent, index);

// If the oldZindex == -1, the component gets inserted,

// rather than it changes its z-order.

if (!peerRecreated && oldZindex != -1) {

// The new 'index' cannot be == -1.

// It gets checked at the checkAdding() method.

// Therefore both oldZIndex and index denote

// some existing positions at this point and

// this is actually a Z-order changing.

comp.mixOnZOrderChanging(oldZindex, index);

}

}

}

/**

private void reparentTraverse(ContainerPeer parentPeer, Container child) {

checkTreeLock();

for (int i = 0; i < child.getComponentCount(); i++) {

Component comp = child.getComponent(i);

if (comp.isLightweight()) {

// If components is lightweight check if it is container

// If it is container it might contain heavyweight children we need to reparent

if (comp instanceof Container) {

reparentTraverse(parentPeer, (Container)comp);

}

} else {

// Q: Need to update NativeInLightFixer?

comp.getPeer().reparent(parentPeer);

}

}

}

/**

private void reparentChild(Component comp) {

checkTreeLock();

if (comp == null) {

return;

}

if (comp.isLightweight()) {

// If component is lightweight container we need to reparent all its explicit heavyweight children

if (comp instanceof Container) {

// Traverse component's tree till depth-first until encountering heavyweight component

reparentTraverse((ContainerPeer)getPeer(), (Container)comp);

}

} else {

comp.getPeer().reparent((ContainerPeer)getPeer());

}

}

/**

private void addDelicately(Component comp, Container curParent, int index) {

checkTreeLock();

// Check if moving between containers

if (curParent != this) {

//index == -1 means add to the end.

if (index == -1) {

component.add(comp);

} else {

component.add(index, comp);

}

comp.parent = this;

comp.setGraphicsConfiguration(getGraphicsConfiguration());

adjustListeningChildren(AWTEvent.HIERARCHY_EVENT_MASK,

comp.numListening(AWTEvent.HIERARCHY_EVENT_MASK));

adjustListeningChildren(AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK,

comp.numListening(AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK));

adjustDescendants(comp.countHierarchyMembers());

} else {

if (index < component.size()) {

component.set(index, comp);

}

}

invalidateIfValid();

if (peer != null) {

if (comp.peer == null) { // Remove notify was called or it didn't have peer - create new one

comp.addNotify();

} else { // Both container and child have peers, it means child peer should be reparented.

// In both cases we need to reparent native widgets.

Container newNativeContainer = getHeavyweightContainer();

Container oldNativeContainer = curParent.getHeavyweightContainer();

if (oldNativeContainer != newNativeContainer) {

// Native container changed - need to reparent native widgets

newNativeContainer.reparentChild(comp);

}

comp.updateZOrder();

if (!comp.isLightweight() && isLightweight()) {

// If component is heavyweight and one of the containers is lightweight

// the location of the component should be fixed.

comp.relocateComponent();

}

}

}

if (curParent != this) {

/* Notify the layout manager of the added component. */

if (layoutMgr != null) {

if (layoutMgr instanceof LayoutManager2) {

((LayoutManager2)layoutMgr).addLayoutComponent(comp, null);

} else {

layoutMgr.addLayoutComponent(null, comp);

}

}

if (containerListener != null ||

(eventMask & AWTEvent.CONTAINER_EVENT_MASK) != 0 ||

Toolkit.enabledOnToolkit(AWTEvent.CONTAINER_EVENT_MASK)) {

ContainerEvent e = new ContainerEvent(this,

ContainerEvent.COMPONENT_ADDED,

comp);

dispatchEvent(e);

}

comp.createHierarchyEvents(HierarchyEvent.HIERARCHY_CHANGED, comp,

this, HierarchyEvent.PARENT_CHANGED,

Toolkit.enabledOnToolkit(AWTEvent.HIERARCHY_EVENT_MASK));

// If component is focus owner or parent container of focus owner check that after reparenting

// focus owner moved out if new container prohibit this kind of focus owner.

if (comp.isFocusOwner() && !comp.canBeFocusOwnerRecursively()) {

comp.transferFocus();

} else if (comp instanceof Container) {

Component focusOwner = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();

if (focusOwner != null && isParentOf(focusOwner) && !focusOwner.canBeFocusOwnerRecursively()) {

focusOwner.transferFocus();

}

}

} else {

comp.createHierarchyEvents(HierarchyEvent.HIERARCHY_CHANGED, comp,

this, HierarchyEvent.HIERARCHY_CHANGED,

Toolkit.enabledOnToolkit(AWTEvent.HIERARCHY_EVENT_MASK));

}

if (peer != null && layoutMgr == null && isVisible()) {

updateCursorImmediately();

}

}

/**

public int getComponentZOrder(Component comp) {

if (comp == null) {

return -1;

}

synchronized(getTreeLock()) {

// Quick check - container should be immediate parent of the component

if (comp.parent != this) {

return -1;

}

return component.indexOf(comp);

}

}

/**

public void add(Component comp, Object constraints) {

addImpl(comp, constraints, -1);

}

/**