Sky at Night 2007 June/SAN CD 6-2007 CD-ROM 25.iso/pc/Software/AstroGrav_Win/Java/jre1.6.0/lib/rt.jar/java/awt/Container.class

Java Class File | 2006-11-29 | 29.7 KB | 1,867 lines

package java.awt;

import java.awt.GraphicsCallback.PaintAllCallback;
import java.awt.GraphicsCallback.PaintCallback;
import java.awt.GraphicsCallback.PaintHeavyweightComponentsCallback;
import java.awt.GraphicsCallback.PrintAllCallback;
import java.awt.GraphicsCallback.PrintCallback;
import java.awt.GraphicsCallback.PrintHeavyweightComponentsCallback;
import java.awt.event.ContainerEvent;
import java.awt.event.ContainerListener;
import java.awt.event.KeyEvent;
import java.awt.peer.ComponentPeer;
import java.awt.peer.ContainerPeer;
import java.awt.peer.LightweightPeer;
import java.beans.PropertyChangeListener;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamField;
import java.io.OptionalDataException;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.Serializable;
import java.security.AccessController;
import java.util.Arrays;
import java.util.EventListener;
import java.util.HashSet;
import java.util.Set;
import javax.accessibility.Accessible;
import javax.accessibility.AccessibleComponent;
import javax.accessibility.AccessibleContext;
import javax.swing.JInternalFrame;
import sun.awt.AppContext;
import sun.awt.DebugHelper;
import sun.awt.PeerEvent;
import sun.awt.SunToolkit;
import sun.awt.CausedFocusEvent.Cause;

public class Container extends Component {
   int ncomponents;
   Component[] component = new Component[0];
   LayoutManager layoutMgr;
   private LightweightDispatcher dispatcher;
   private transient FocusTraversalPolicy focusTraversalPolicy;
   private boolean focusCycleRoot = false;
   private boolean focusTraversalPolicyProvider;
   private transient Set printingThreads;
   private transient boolean printing = false;
   transient ContainerListener containerListener;
   transient int listeningChildren;
   transient int listeningBoundsChildren;
   transient int descendantsCount;
   private static final long serialVersionUID = 4613797578919906343L;
   private static final DebugHelper dbg = DebugHelper.create(Container.class);
   static final boolean INCLUDE_SELF = true;
   static final boolean SEARCH_HEAVYWEIGHTS = true;
   private static final ObjectStreamField[] serialPersistentFields;
   transient Component modalComp;
   transient AppContext modalAppContext;
   private int containerSerializedDataVersion = 1;

   private static native void initIDs();

   void initializeFocusTraversalKeys() {
      this.focusTraversalKeys = new Set[4];
   }

   public int getComponentCount() {
      return this.countComponents();
   }

   /** @deprecated */
   @Deprecated
   public int countComponents() {
      return this.ncomponents;
   }

   public Component getComponent(int var1) {
      synchronized(this.getTreeLock()) {
         if (var1 >= 0 && var1 < this.ncomponents) {
            return this.component[var1];
         } else {
            throw new ArrayIndexOutOfBoundsException("No such child: " + var1);
         }
      }
   }

   public Component[] getComponents() {
      return this.getComponents_NoClientCode();
   }

   final Component[] getComponents_NoClientCode() {
      synchronized(this.getTreeLock()) {
         return (Component[])Arrays.copyOf(this.component, this.ncomponents);
      }
   }

   public Insets getInsets() {
      return this.insets();
   }

   /** @deprecated */
   @Deprecated
   public Insets insets() {
      ComponentPeer var1 = this.peer;
      if (var1 instanceof ContainerPeer) {
         ContainerPeer var2 = (ContainerPeer)var1;
         return (Insets)var2.insets().clone();
      } else {
         return new Insets(0, 0, 0, 0);
      }
   }

   public Component add(Component var1) {
      this.addImpl(var1, (Object)null, -1);
      return var1;
   }

   public Component add(String var1, Component var2) {
      this.addImpl(var2, var1, -1);
      return var2;
   }

   public Component add(Component var1, int var2) {
      this.addImpl(var1, (Object)null, var2);
      return var1;
   }

   void checkTreeLock() {
      if (!Thread.holdsLock(this.getTreeLock())) {
         throw new IllegalStateException("This function should be called while holding treeLock");
      }
   }

   private void checkAdding(Component var1, int var2) {
      this.checkTreeLock();
      GraphicsConfiguration var3 = this.getGraphicsConfiguration();
      if (var2 <= this.ncomponents && var2 >= 0) {
         if (var1.parent == this && var2 == this.ncomponents) {
            throw new IllegalArgumentException("illegal component position " + var2 + " should be less then " + this.ncomponents);
         } else {
            if (var1 instanceof Container) {
               for(Container var4 = this; var4 != null; var4 = var4.parent) {
                  if (var4 == var1) {
                     throw new IllegalArgumentException("adding container's parent to itself");
                  }
               }

               if (var1 instanceof Window) {
                  throw new IllegalArgumentException("adding a window to a container");
               }
            }

            Window var6 = this.getContainingWindow();
            Window var5 = var1.getContainingWindow();
            if (var6 != var5) {
               throw new IllegalArgumentException("component and container should be in the same top-level window");
            } else {
               if (var3 != null) {
                  var1.checkGD(var3.getDevice().getIDstring());
               }

            }
         }
      } else {
         throw new IllegalArgumentException("illegal component position");
      }
   }

   private void removeDelicately(Component var1, Container var2, int var3) {
      this.checkTreeLock();
      int var4 = this.getComponentZOrder(var1);
      if (isRemoveNotifyNeeded(var1, this, var2)) {
         var1.removeNotify();
      }

      if (var2 != this) {
         if (this.layoutMgr != null) {
            this.layoutMgr.removeLayoutComponent(var1);
         }

         this.adjustListeningChildren(32768L, -var1.numListening(32768L));
         this.adjustListeningChildren(65536L, -var1.numListening(65536L));
         this.adjustDescendants(-var1.countHierarchyMembers());
         var1.parent = null;
         System.arraycopy(this.component, var4 + 1, this.component, var4, this.ncomponents - var4 - 1);
         this.component[--this.ncomponents] = null;
         if (this.valid) {
            this.invalidate();
         }
      } else {
         if (var3 > var4) {
            if (var3 - var4 > 0) {
               System.arraycopy(this.component, var4 + 1, this.component, var4, var3 - var4);
            }
         } else if (var4 - var3 > 0) {
            System.arraycopy(this.component, var3, this.component, var3 + 1, var4 - var3);
         }

         this.component[var3] = var1;
      }

      if (var1.parent == null) {
         if (this.containerListener != null || (this.eventMask & 2L) != 0L || Toolkit.enabledOnToolkit(2L)) {
            ContainerEvent var5 = new ContainerEvent(this, 301, var1);
            this.dispatchEvent(var5);
         }

         var1.createHierarchyEvents(1400, var1, this, 1L, Toolkit.enabledOnToolkit(32768L));
         if (this.peer != null && this.layoutMgr == null && this.isVisible()) {
            this.updateCursorImmediately();
         }
      }

   }

   boolean canContainFocusOwner(Component var1) {
      if (this.isEnabled() && this.isDisplayable() && this.isVisible() && this.isFocusable()) {
         if (this.isFocusCycleRoot()) {
            FocusTraversalPolicy var2 = this.getFocusTraversalPolicy();
            if (var2 instanceof DefaultFocusTraversalPolicy && !((DefaultFocusTraversalPolicy)var2).accept(var1)) {
               return false;
            }
         }

         synchronized(this.getTreeLock()) {
            return this.parent != null ? this.parent.canContainFocusOwner(var1) : true;
         }
      } else {
         return false;
      }
   }

   private boolean hasHeavyweightChildren() {
      this.checkTreeLock();
      boolean var1 = true;

      for(int var2 = 0; var2 < this.getComponentCount() && var1; ++var2) {
         Component var3 = this.getComponent(var2);
         var1 &= var3.isLightweight();
         if (var1 && var3 instanceof Container) {
            var1 &= !((Container)var3).hasHeavyweightChildren();
         }
      }

      return !var1;
   }

   Container getHeavyweightContainer() {
      this.checkTreeLock();
      return this.peer != null && !(this.peer instanceof LightweightPeer) ? this : this.getNativeContainer();
   }

   private static boolean isRemoveNotifyNeeded(Component var0, Container var1, Container var2) {
      if (var1 == null) {
         return false;
      } else if (var0.peer == null) {
         return false;
      } else if (var2.peer == null) {
         return true;
      } else if (var0.isLightweight()) {
         return var0 instanceof Container ? ((Container)var0).hasHeavyweightChildren() : false;
      } else {
         Container var3 = var1.getHeavyweightContainer();
         Container var4 = var2.getHeavyweightContainer();
         if (var3 != var4) {
            return !var0.peer.isReparentSupported();
         } else {
            return !var0.isLightweight() && !((ContainerPeer)((ContainerPeer)var3.peer)).isRestackSupported();
         }
      }
   }

   public void setComponentZOrder(Component var1, int var2) {
      synchronized(this.getTreeLock()) {
         Container var4 = var1.parent;
         if (var4 != this || var2 != this.getComponentZOrder(var1)) {
            this.checkAdding(var1, var2);
            if (var4 != null) {
               var4.removeDelicately(var1, this, var2);
            }

            this.addDelicately(var1, var4, var2);
         }
      }
   }

   private void reparentTraverse(ContainerPeer var1, Container var2) {
      this.checkTreeLock();

      for(int var3 = 0; var3 < var2.getComponentCount(); ++var3) {
         Component var4 = var2.getComponent(var3);
         if (var4.isLightweight()) {
            if (var4 instanceof Container) {
               this.reparentTraverse(var1, (Container)var4);
            }
         } else {
            var4.getPeer().reparent(var1);
         }
      }

   }

   private void reparentChild(Component var1) {
      this.checkTreeLock();
      if (var1 != null) {
         if (var1.isLightweight()) {
            if (var1 instanceof Container) {
               this.reparentTraverse((ContainerPeer)this.getPeer(), (Container)var1);
            }
         } else {
            var1.getPeer().reparent((ContainerPeer)this.getPeer());
         }

      }
   }

   private void addDelicately(Component var1, Container var2, int var3) {
      this.checkTreeLock();
      if (var2 != this) {
         if (this.ncomponents == this.component.length) {
            this.component = (Component[])Arrays.copyOf(this.component, this.ncomponents * 2 + 1);
         }

         if (var3 != -1 && var3 != this.ncomponents) {
            System.arraycopy(this.component, var3, this.component, var3 + 1, this.ncomponents - var3);
            this.component[var3] = var1;
            ++this.ncomponents;
         } else {
            this.component[this.ncomponents++] = var1;
         }

         var1.parent = this;
         this.adjustListeningChildren(32768L, var1.numListening(32768L));
         this.adjustListeningChildren(65536L, var1.numListening(65536L));
         this.adjustDescendants(var1.countHierarchyMembers());
      } else if (var3 < this.ncomponents) {
         this.component[var3] = var1;
      }

      if (this.valid) {
         this.invalidate();
      }

      if (this.peer != null) {
         if (var1.peer == null) {
            var1.addNotify();
            Container var4 = this.getHeavyweightContainer();
            if (((ContainerPeer)var4.getPeer()).isRestackSupported()) {
               ((ContainerPeer)var4.getPeer()).restack();
            }
         } else {
            Container var6 = this.getHeavyweightContainer();
            Container var5 = var2.getHeavyweightContainer();
            if (var5 != var6) {
               var6.reparentChild(var1);
            }

            if ((!var1.isLightweight() || var1 instanceof Container) && ((ContainerPeer)var6.getPeer()).isRestackSupported()) {
               ((ContainerPeer)var6.getPeer()).restack();
            }

            if (!var1.isLightweight() && this.isLightweight()) {
               if (!var2.isLightweight()) {
                  var1.nativeInLightFixer = new Component.NativeInLightFixer(this);
               } else {
                  var1.nativeInLightFixer.install(this);
               }
            }
         }
      }

      if (var2 != this) {
         if (this.layoutMgr != null) {
            if (this.layoutMgr instanceof LayoutManager2) {
               ((LayoutManager2)this.layoutMgr).addLayoutComponent(var1, (Object)null);
            } else {
               this.layoutMgr.addLayoutComponent((String)null, var1);
            }
         }

         if (this.containerListener != null || (this.eventMask & 2L) != 0L || Toolkit.enabledOnToolkit(2L)) {
            ContainerEvent var7 = new ContainerEvent(this, 300, var1);
            this.dispatchEvent(var7);
         }

         var1.createHierarchyEvents(1400, var1, this, 1L, Toolkit.enabledOnToolkit(32768L));
         if (var1.isFocusOwner() && !var1.canBeFocusOwner()) {
            var1.transferFocus();
         } else if (var1 instanceof Container) {
            Component var8 = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner();
            if (var8 != null && this.isParentOf(var8) && !var8.canBeFocusOwner()) {
               var8.transferFocus();
            }
         }
      } else {
         var1.createHierarchyEvents(1400, var1, this, 1400L, Toolkit.enabledOnToolkit(32768L));
      }

      if (this.peer != null && this.layoutMgr == null && this.isVisible()) {
         this.updateCursorImmediately();
      }

   }

   public int getComponentZOrder(Component var1) {
      if (var1 == null) {
         return -1;
      } else {
         synchronized(this.getTreeLock()) {
            if (var1.parent != this) {
               return -1;
            } else {
               for(int var3 = 0; var3 < this.ncomponents; ++var3) {
                  if (this.component[var3] == var1) {
                     return var3;
                  }
               }

               return -1;
            }
         }
      }
   }

   public void add(Component var1, Object var2) {
      this.addImpl(var1, var2, -1);
   }

   public void add(Component var1, Object var2, int var3) {
      this.addImpl(var1, var2, var3);
   }

   protected void addImpl(Component var1, Object var2, int var3) {
      synchronized(this.getTreeLock()) {
         GraphicsConfiguration var5 = this.getGraphicsConfiguration();
         if (var3 <= this.ncomponents && (var3 >= 0 || var3 == -1)) {
            if (var1 instanceof Container) {
               for(Container var6 = this; var6 != null; var6 = var6.parent) {
                  if (var6 == var1) {
                     throw new IllegalArgumentException("adding container's parent to itself");
                  }
               }

               if (var1 instanceof Window) {
                  throw new IllegalArgumentException("adding a window to a container");
               }
            }

            if (var5 != null) {
               var1.checkGD(var5.getDevice().getIDstring());
            }

            if (var1.parent != null) {
               var1.parent.remove(var1);
               if (var3 > this.ncomponents) {
                  throw new IllegalArgumentException("illegal component position");
               }
            }

            if (this.ncomponents == this.component.length) {
               this.component = (Component[])Arrays.copyOf(this.component, this.ncomponents * 2 + 1);
            }

            if (var3 != -1 && var3 != this.ncomponents) {
               System.arraycopy(this.component, var3, this.component, var3 + 1, this.ncomponents - var3);
               this.component[var3] = var1;
               ++this.ncomponents;
            } else {
               this.component[this.ncomponents++] = var1;
            }

            var1.parent = this;
            this.adjustListeningChildren(32768L, var1.numListening(32768L));
            this.adjustListeningChildren(65536L, var1.numListening(65536L));
            this.adjustDescendants(var1.countHierarchyMembers());
            if (this.valid) {
               this.invalidate();
            }

            if (this.peer != null) {
               var1.addNotify();
            }

            if (this.layoutMgr != null) {
               if (this.layoutMgr instanceof LayoutManager2) {
                  ((LayoutManager2)this.layoutMgr).addLayoutComponent(var1, var2);
               } else if (var2 instanceof String) {
                  this.layoutMgr.addLayoutComponent((String)var2, var1);
               }
            }

            if (this.containerListener != null || (this.eventMask & 2L) != 0L || Toolkit.enabledOnToolkit(2L)) {
               ContainerEvent var9 = new ContainerEvent(this, 300, var1);
               this.dispatchEvent(var9);
            }

            var1.createHierarchyEvents(1400, var1, this, 1L, Toolkit.enabledOnToolkit(32768L));
            if (this.peer != null && this.layoutMgr == null && this.isVisible()) {
               this.updateCursorImmediately();
            }

         } else {
            throw new IllegalArgumentException("illegal component position");
         }
      }
   }

   void checkGD(String var1) {
      for(int var3 = 0; var3 < this.component.length; ++var3) {
         Component var2 = this.component[var3];
         if (var2 != null) {
            var2.checkGD(var1);
         }
      }

   }

   public void remove(int var1) {
      synchronized(this.getTreeLock()) {
         if (var1 >= 0 && var1 < this.ncomponents) {
            Component var3 = this.component[var1];
            if (this.peer != null) {
               var3.removeNotify();
            }

            if (this.layoutMgr != null) {
               this.layoutMgr.removeLayoutComponent(var3);
            }

            this.adjustListeningChildren(32768L, -var3.numListening(32768L));
            this.adjustListeningChildren(65536L, -var3.numListening(65536L));
            this.adjustDescendants(-var3.countHierarchyMembers());
            var3.parent = null;
            System.arraycopy(this.component, var1 + 1, this.component, var1, this.ncomponents - var1 - 1);
            this.component[--this.ncomponents] = null;
            if (this.valid) {
               this.invalidate();
            }

            if (this.containerListener != null || (this.eventMask & 2L) != 0L || Toolkit.enabledOnToolkit(2L)) {
               ContainerEvent var4 = new ContainerEvent(this, 301, var3);
               this.dispatchEvent(var4);
            }

            var3.createHierarchyEvents(1400, var3, this, 1L, Toolkit.enabledOnToolkit(32768L));
            if (this.peer != null && this.layoutMgr == null && this.isVisible()) {
               this.updateCursorImmediately();
            }

         } else {
            throw new ArrayIndexOutOfBoundsException(var1);
         }
      }
   }

   public void remove(Component var1) {
      synchronized(this.getTreeLock()) {
         if (var1.parent == this) {
            Component[] var3 = this.component;
            int var4 = this.ncomponents;

            while(true) {
               --var4;
               if (var4 < 0) {
                  break;
               }

               if (var3[var4] == var1) {
                  this.remove(var4);
               }
            }
         }

      }
   }

   public void removeAll() {
      synchronized(this.getTreeLock()) {
         this.adjustListeningChildren(32768L, -this.listeningChildren);
         this.adjustListeningChildren(65536L, -this.listeningBoundsChildren);
         this.adjustDescendants(-this.descendantsCount);

         Component var2;
         for(; this.ncomponents > 0; var2.createHierarchyEvents(1400, var2, this, 1L, Toolkit.enabledOnToolkit(32768L))) {
            var2 = this.component[--this.ncomponents];
            this.component[this.ncomponents] = null;
            if (this.peer != null) {
               var2.removeNotify();
            }

            if (this.layoutMgr != null) {
               this.layoutMgr.removeLayoutComponent(var2);
            }

            var2.parent = null;
            if (this.containerListener != null || (this.eventMask & 2L) != 0L || Toolkit.enabledOnToolkit(2L)) {
               ContainerEvent var3 = new ContainerEvent(this, 301, var2);
               this.dispatchEvent(var3);
            }
         }

         if (this.peer != null && this.layoutMgr == null && this.isVisible()) {
            this.updateCursorImmediately();
         }

         if (this.valid) {
            this.invalidate();
         }

      }
   }

   int numListening(long var1) {
      int var3 = super.numListening(var1);
      if (var1 == 32768L) {
         DebugHelper var5 = dbg;
         return this.listeningChildren + var3;
      } else if (var1 == 65536L) {
         DebugHelper var4 = dbg;
         return this.listeningBoundsChildren + var3;
      } else {
         DebugHelper var10000 = dbg;
         return var3;
      }
   }

   void adjustListeningChildren(long var1, int var3) {
      DebugHelper var10000 = dbg;
      if (var3 != 0) {
         if ((var1 & 32768L) != 0L) {
            this.listeningChildren += var3;
         }

         if ((var1 & 65536L) != 0L) {
            this.listeningBoundsChildren += var3;
         }

         this.adjustListeningChildrenOnParent(var1, var3);
      }
   }

   void adjustDescendants(int var1) {
      if (var1 != 0) {
         this.descendantsCount += var1;
         this.adjustDecendantsOnParent(var1);
      }
   }

   void adjustDecendantsOnParent(int var1) {
      if (this.parent != null) {
         this.parent.adjustDescendants(var1);
      }

   }

   int countHierarchyMembers() {
      DebugHelper var10000 = dbg;
      return this.descendantsCount + 1;
   }

   private int getListenersCount(int var1, boolean var2) {
      assert Thread.holdsLock(this.getTreeLock());

      if (var2) {
         return this.descendantsCount;
      } else {
         switch (var1) {
            case 1400:
               return this.listeningChildren;
            case 1401:
            case 1402:
               return this.listeningBoundsChildren;
            default:
               return 0;
         }
      }
   }

   final int createHierarchyEvents(int var1, Component var2, Container var3, long var4, boolean var6) {
      assert Thread.holdsLock(this.getTreeLock());

      int var7 = this.getListenersCount(var1, var6);
      int var8 = var7;

      for(int var9 = 0; var8 > 0; ++var9) {
         var8 -= this.component[var9].createHierarchyEvents(var1, var2, var3, var4, var6);
      }

      return var7 + super.createHierarchyEvents(var1, var2, var3, var4, var6);
   }

   final void createChildHierarchyEvents(int var1, long var2, boolean var4) {
      assert Thread.holdsLock(this.getTreeLock());

      if (this.ncomponents != 0) {
         int var5 = this.getListenersCount(var1, var4);
         int var6 = var5;

         for(int var7 = 0; var6 > 0; ++var7) {
            var6 -= this.component[var7].createHierarchyEvents(var1, this, this.parent, var2, var4);
         }

      }
   }

   public LayoutManager getLayout() {
      return this.layoutMgr;
   }

   public void setLayout(LayoutManager var1) {
      this.layoutMgr = var1;
      if (this.valid) {
         this.invalidate();
      }

   }

   public void doLayout() {
      this.layout();
   }

   /** @deprecated */
   @Deprecated
   public void layout() {
      LayoutManager var1 = this.layoutMgr;
      if (var1 != null) {
         var1.layoutContainer(this);
      }

   }

   public void invalidate() {
      LayoutManager var1 = this.layoutMgr;
      if (var1 instanceof LayoutManager2) {
         LayoutManager2 var2 = (LayoutManager2)var1;
         var2.invalidateLayout(this);
      }

      super.invalidate();
   }

   public void validate() {
      if (!this.valid) {
         boolean var1 = false;
         synchronized(this.getTreeLock()) {
            if (!this.valid && this.peer != null) {
               ContainerPeer var3 = null;
               if (this.peer instanceof ContainerPeer) {
                  var3 = (ContainerPeer)this.peer;
               }

               if (var3 != null) {
                  var3.beginValidate();
               }

               this.validateTree();
               this.valid = true;
               if (var3 != null) {
                  var3.endValidate();
                  var1 = this.isVisible();
               }
            }
         }

         if (var1) {
            this.updateCursorImmediately();
         }
      }

   }

   protected void validateTree() {
      if (!this.valid) {
         if (this.peer instanceof ContainerPeer) {
            ((ContainerPeer)this.peer).beginLayout();
         }

         this.doLayout();
         Component[] var1 = this.component;

         for(int var2 = 0; var2 < this.ncomponents; ++var2) {
            Component var3 = var1[var2];
            if (var3 instanceof Container && !(var3 instanceof Window) && !var3.valid) {
               ((Container)var3).validateTree();
            } else {
               var3.validate();
            }
         }

         if (this.peer instanceof ContainerPeer) {
            ((ContainerPeer)this.peer).endLayout();
         }
      }

      this.valid = true;
   }

   void invalidateTree() {
      synchronized(this.getTreeLock()) {
         for(int var2 = 0; var2 < this.ncomponents; ++var2) {
            Component var3 = this.component[var2];
            if (var3 instanceof Container) {
               ((Container)var3).invalidateTree();
            } else if (var3.valid) {
               var3.invalidate();
            }
         }

         if (this.valid) {
            this.invalidate();
         }

      }
   }

   public void setFont(Font var1) {
      boolean var2 = false;
      Font var3 = this.getFont();
      super.setFont(var1);
      Font var4 = this.getFont();
      if (var4 != var3 && (var3 == null || !var3.equals(var4))) {
         this.invalidateTree();
      }

   }

   public Dimension getPreferredSize() {
      return this.preferredSize();
   }

   /** @deprecated */
   @Deprecated
   public Dimension preferredSize() {
      Dimension var1 = this.prefSize;
      if (var1 == null || !this.isPreferredSizeSet() && !this.isValid()) {
         synchronized(this.getTreeLock()) {
            this.prefSize = this.layoutMgr != null ? this.layoutMgr.preferredLayoutSize(this) : super.preferredSize();
            var1 = this.prefSize;
         }
      }

      return var1 != null ? new Dimension(var1) : var1;
   }

   public Dimension getMinimumSize() {
      return this.minimumSize();
   }

   /** @deprecated */
   @Deprecated
   public Dimension minimumSize() {
      Dimension var1 = this.minSize;
      if (var1 == null || !this.isMinimumSizeSet() && !this.isValid()) {
         synchronized(this.getTreeLock()) {
            this.minSize = this.layoutMgr != null ? this.layoutMgr.minimumLayoutSize(this) : super.minimumSize();
            var1 = this.minSize;
         }
      }

      return var1 != null ? new Dimension(var1) : var1;
   }

   public Dimension getMaximumSize() {
      Dimension var1 = this.maxSize;
      if (var1 == null || !this.isMaximumSizeSet() && !this.isValid()) {
         synchronized(this.getTreeLock()) {
            if (this.layoutMgr instanceof LayoutManager2) {
               LayoutManager2 var3 = (LayoutManager2)this.layoutMgr;
               this.maxSize = var3.maximumLayoutSize(this);
            } else {
               this.maxSize = super.getMaximumSize();
            }

            var1 = this.maxSize;
         }
      }

      return var1 != null ? new Dimension(var1) : var1;
   }

   public float getAlignmentX() {
      float var1;
      if (this.layoutMgr instanceof LayoutManager2) {
         synchronized(this.getTreeLock()) {
            LayoutManager2 var3 = (LayoutManager2)this.layoutMgr;
            var1 = var3.getLayoutAlignmentX(this);
         }
      } else {
         var1 = super.getAlignmentX();
      }

      return var1;
   }

   public float getAlignmentY() {
      float var1;
      if (this.layoutMgr instanceof LayoutManager2) {
         synchronized(this.getTreeLock()) {
            LayoutManager2 var3 = (LayoutManager2)this.layoutMgr;
            var1 = var3.getLayoutAlignmentY(this);
         }
      } else {
         var1 = super.getAlignmentY();
      }

      return var1;
   }

   public void paint(Graphics var1) {
      if (this.isShowing()) {
         if (this.printing) {
            synchronized(this) {
               if (this.printing && this.printingThreads.contains(Thread.currentThread())) {
                  return;
               }
            }
         }

         PaintCallback.getInstance().runComponents(this.component, var1, 2);
      }

   }

   public void update(Graphics var1) {
      if (this.isShowing()) {
         if (!(this.peer instanceof LightweightPeer)) {
            var1.clearRect(0, 0, this.width, this.height);
         }

         this.paint(var1);
      }

   }

   public void print(Graphics var1) {
      if (this.isShowing()) {
         Thread var2 = Thread.currentThread();

         try {
            synchronized(this) {
               if (this.printingThreads == null) {
                  this.printingThreads = new HashSet();
               }

               this.printingThreads.add(var2);
               this.printing = true;
            }

            super.print(var1);
         } finally {
            synchronized(this) {
               this.printingThreads.remove(var2);
               this.printing = !this.printingThreads.isEmpty();
            }
         }

         PrintCallback.getInstance().runComponents(this.component, var1, 2);
      }

   }

   public void paintComponents(Graphics var1) {
      if (this.isShowing()) {
         PaintAllCallback.getInstance().runComponents(this.component, var1, 4);
      }

   }

   void lightweightPaint(Graphics var1) {
      super.lightweightPaint(var1);
      this.paintHeavyweightComponents(var1);
   }

   void paintHeavyweightComponents(Graphics var1) {
      if (this.isShowing()) {
         PaintHeavyweightComponentsCallback.getInstance().runComponents(this.component, var1, 3);
      }

   }

   public void printComponents(Graphics var1) {
      if (this.isShowing()) {
         PrintAllCallback.getInstance().runComponents(this.component, var1, 4);
      }

   }

   void lightweightPrint(Graphics var1) {
      super.lightweightPrint(var1);
      this.printHeavyweightComponents(var1);
   }

   void printHeavyweightComponents(Graphics var1) {
      if (this.isShowing()) {
         PrintHeavyweightComponentsCallback.getInstance().runComponents(this.component, var1, 3);
      }

   }

   public synchronized void addContainerListener(ContainerListener var1) {
      if (var1 != null) {
         this.containerListener = AWTEventMulticaster.add(this.containerListener, var1);
         this.newEventsOnly = true;
      }
   }

   public synchronized void removeContainerListener(ContainerListener var1) {
      if (var1 != null) {
         this.containerListener = AWTEventMulticaster.remove(this.containerListener, var1);
      }
   }

   public synchronized ContainerListener[] getContainerListeners() {
      return (ContainerListener[])this.getListeners(ContainerListener.class);
   }

   public <T extends EventListener> T[] getListeners(Class<T> var1) {
      Object var2 = null;
      if (var1 == ContainerListener.class) {
         ContainerListener var3 = this.containerListener;
         return (T[])AWTEventMulticaster.getListeners(var3, var1);
      } else {
         return (T[])super.getListeners(var1);
      }
   }

   boolean eventEnabled(AWTEvent var1) {
      int var2 = var1.getID();
      if (var2 != 300 && var2 != 301) {
         return super.eventEnabled(var1);
      } else {
         return (this.eventMask & 2L) != 0L || this.containerListener != null;
      }
   }

   protected void processEvent(AWTEvent var1) {
      if (var1 instanceof ContainerEvent) {
         this.processContainerEvent((ContainerEvent)var1);
      } else {
         super.processEvent(var1);
      }
   }

   protected void processContainerEvent(ContainerEvent var1) {
      ContainerListener var2 = this.containerListener;
      if (var2 != null) {
         switch (var1.getID()) {
            case 300:
               var2.componentAdded(var1);
               break;
            case 301:
               var2.componentRemoved(var1);
         }
      }

   }

   void dispatchEventImpl(AWTEvent var1) {
      if (this.dispatcher != null && this.dispatcher.dispatchEvent(var1)) {
         var1.consume();
         if (this.peer != null) {
            this.peer.handleEvent(var1);
         }

      } else {
         super.dispatchEventImpl(var1);
         synchronized(this.getTreeLock()) {
            switch (var1.getID()) {
               case 100:
                  this.createChildHierarchyEvents(1401, 0L, Toolkit.enabledOnToolkit(65536L));
                  break;
               case 101:
                  this.createChildHierarchyEvents(1402, 0L, Toolkit.enabledOnToolkit(65536L));
            }

         }
      }
   }

   void dispatchEventToSelf(AWTEvent var1) {
      super.dispatchEventImpl(var1);
   }

   Component getMouseEventTarget(int var1, int var2, boolean var3) {
      return this.getMouseEventTarget(var1, var2, var3, java.awt.Container.MouseEventTargetFilter.FILTER, false);
   }

   Component getDropTargetEventTarget(int var1, int var2, boolean var3) {
      return this.getMouseEventTarget(var1, var2, var3, java.awt.Container.DropTargetEventTargetFilter.FILTER, true);
   }

   private Component getMouseEventTarget(int var1, int var2, boolean var3, EventTargetFilter var4, boolean var5) {
      Component var6 = null;
      if (var5) {
         var6 = this.getMouseEventTargetImpl(var1, var2, var3, var4, true, var5);
      }

      if (var6 == null || var6 == this) {
         var6 = this.getMouseEventTargetImpl(var1, var2, var3, var4, false, var5);
      }

      return var6;
   }

   private Component getMouseEventTargetImpl(int var1, int var2, boolean var3, EventTargetFilter var4, boolean var5, boolean var6) {
      int var7 = this.ncomponents;
      Component[] var8 = this.component;

      for(int var9 = 0; var9 < var7; ++var9) {
         Component var10 = var8[var9];
         if (var10 != null && var10.visible && (!var5 && var10.peer instanceof LightweightPeer || var5 && !(var10.peer instanceof LightweightPeer)) && var10.contains(var1 - var10.x, var2 - var10.y)) {
            if (var10 instanceof Container) {
               Container var11 = (Container)var10;
               Component var12 = var11.getMouseEventTarget(var1 - var11.x, var2 - var11.y, var3, var4, var6);
               if (var12 != null) {
                  return var12;
               }
            } else if (var4.accept(var10)) {
               return var10;
            }
         }
      }

      boolean var13 = this.peer instanceof LightweightPeer || var3;
      boolean var14 = this.contains(var1, var2);
      if (var14 && var13 && var4.accept(this)) {
         return this;
      } else {
         return null;
      }
   }

   void proxyEnableEvents(long var1) {
      if (this.peer instanceof LightweightPeer) {
         if (this.parent != null) {
            this.parent.proxyEnableEvents(var1);
         }
      } else if (this.dispatcher != null) {
         this.dispatcher.enableEvents(var1);
      }

   }

   /** @deprecated */
   @Deprecated
   public void deliverEvent(Event var1) {
      Component var2 = this.getComponentAt(var1.x, var1.y);
      if (var2 != null && var2 != this) {
         var1.translate(-var2.x, -var2.y);
         var2.deliverEvent(var1);
      } else {
         this.postEvent(var1);
      }

   }

   public Component getComponentAt(int var1, int var2) {
      return this.locate(var1, var2);
   }

   /** @deprecated */
   @Deprecated
   public Component locate(int var1, int var2) {
      if (!this.contains(var1, var2)) {
         return null;
      } else {
         synchronized(this.getTreeLock()) {
            for(int var4 = 0; var4 < this.ncomponents; ++var4) {
               Component var5 = this.component[var4];
               if (var5 != null && !(var5.peer instanceof LightweightPeer) && var5.contains(var1 - var5.x, var2 - var5.y)) {
                  return var5;
               }
            }

            for(int var8 = 0; var8 < this.ncomponents; ++var8) {
               Component var9 = this.component[var8];
               if (var9 != null && var9.peer instanceof LightweightPeer && var9.contains(var1 - var9.x, var2 - var9.y)) {
                  return var9;
               }
            }

            return this;
         }
      }
   }

   public Component getComponentAt(Point var1) {
      return this.getComponentAt(var1.x, var1.y);
   }

   public Point getMousePosition(boolean var1) throws HeadlessException {
      if (GraphicsEnvironment.isHeadless()) {
         throw new HeadlessException();
      } else {
         PointerInfo var2 = (PointerInfo)AccessController.doPrivileged(new 1(this));
         synchronized(this.getTreeLock()) {
            Component var4 = this.findUnderMouseInWindow(var2);
            return this.isSameOrAncestorOf(var4, var1) ? this.pointRelativeToComponent(var2.getLocation()) : null;
         }
      }
   }

   boolean isSameOrAncestorOf(Component var1, boolean var2) {
      return this == var1 || var2 && this.isParentOf(var1);
   }

   public Component findComponentAt(int var1, int var2) {
      synchronized(this.getTreeLock()) {
         return this.findComponentAt(var1, var2, true);
      }
   }

   final Component findComponentAt(int var1, int var2, boolean var3) {
      return this.isRecursivelyVisible() ? this.findComponentAtImpl(var1, var2, var3) : null;
   }

   final Component findComponentAtImpl(int var1, int var2, boolean var3) {
      if (this.contains(var1, var2) && this.visible && (var3 || this.enabled)) {
         int var4 = this.ncomponents;
         Component[] var5 = this.component;

         for(int var6 = 0; var6 < var4; ++var6) {
            Component var7 = var5[var6];
            if (var7 != null && !(var7.peer instanceof LightweightPeer)) {
               if (var7 instanceof Container) {
                  var7 = ((Container)var7).findComponentAtImpl(var1 - var7.x, var2 - var7.y, var3);
               } else {
                  var7 = var7.locate(var1 - var7.x, var2 - var7.y);
               }

               if (var7 != null && var7.visible && (var3 || var7.enabled)) {
                  return var7;
               }
            }
         }

         for(int var8 = 0; var8 < var4; ++var8) {
            Component var10 = var5[var8];
            if (var10 != null && var10.peer instanceof LightweightPeer) {
               if (var10 instanceof Container) {
                  var10 = ((Container)var10).findComponentAtImpl(var1 - var10.x, var2 - var10.y, var3);
               } else {
                  var10 = var10.locate(var1 - var10.x, var2 - var10.y);
               }

               if (var10 != null && var10.visible && (var3 || var10.enabled)) {
                  return var10;
               }
            }
         }

         return this;
      } else {
         return null;
      }
   }

   public Component findComponentAt(Point var1) {
      return this.findComponentAt(var1.x, var1.y);
   }

   public void addNotify() {
      synchronized(this.getTreeLock()) {
         super.addNotify();
         if (!(this.peer instanceof LightweightPeer)) {
            this.dispatcher = new LightweightDispatcher(this);
         }

         int var2 = this.ncomponents;
         Component[] var3 = this.component;

         for(int var4 = 0; var4 < var2; ++var4) {
            var3[var4].addNotify();
         }

         ContainerPeer var7 = (ContainerPeer)this.peer;
         if (var7.isRestackSupported()) {
            var7.restack();
         }

      }
   }

   public void removeNotify() {
      synchronized(this.getTreeLock()) {
         int var2 = this.ncomponents;
         Component[] var3 = this.component;

         for(int var4 = var2 - 1; var4 >= 0; --var4) {
            if (var3[var4] != null) {
               var3[var4].removeNotify();
            }
         }

         if (this.dispatcher != null) {
            this.dispatcher.dispose();
            this.dispatcher = null;
         }

         super.removeNotify();
      }
   }

   public boolean isAncestorOf(Component var1) {
      Container var2;
      if (var1 != null && (var2 = var1.getParent()) != null) {
         while(var2 != null) {
            if (var2 == this) {
               return true;
            }

            var2 = var2.getParent();
         }

         return false;
      } else {
         return false;
      }
   }

   private void startLWModal() {
      this.modalAppContext = AppContext.getAppContext();
      Toolkit.getEventQueue();
      long var1 = EventQueue.getMostRecentEventTime();
      Component var3 = Component.isInstanceOf(this, "javax.swing.JInternalFrame") ? ((JInternalFrame)((JInternalFrame)this)).getMostRecentFocusOwner() : null;
      if (var3 != null) {
         KeyboardFocusManager.getCurrentKeyboardFocusManager().enqueueKeyEvents(var1, var3);
      }

      Container var4;
      synchronized(this.getTreeLock()) {
         var4 = this.getHeavyweightContainer();
         if (var4.modalComp != null) {
            this.modalComp = var4.modalComp;
            var4.modalComp = this;
            return;
         }

         var4.modalComp = this;
      }

      2 var5 = new 2(this, var4);
      if (EventQueue.isDispatchThread()) {
         SequencedEvent var6 = KeyboardFocusManager.getCurrentKeyboardFocusManager().getCurrentSequencedEvent();
         if (var6 != null) {
            var6.dispose();
         }

         var5.run();
      } else {
         synchronized(this.getTreeLock()) {
            Toolkit.getEventQueue().postEvent(new PeerEvent(this, var5, 1L));

            while(this.windowClosingException == null) {
               try {
                  this.getTreeLock().wait();
               } catch (InterruptedException var9) {
                  break;
               }
            }
         }
      }

      if (this.windowClosingException != null) {
         this.windowClosingException.fillInStackTrace();
         throw this.windowClosingException;
      } else {
         if (var3 != null) {
            KeyboardFocusManager.getCurrentKeyboardFocusManager().dequeueKeyEvents(var1, var3);
         }

      }
   }

   private void stopLWModal() {
      synchronized(this.getTreeLock()) {
         if (this.modalAppContext != null) {
            Container var2 = this.getHeavyweightContainer();
            if (var2 != null) {
               if (this.modalComp != null) {
                  var2.modalComp = this.modalComp;
                  this.modalComp = null;
                  return;
               }

               var2.modalComp = null;
            }

            SunToolkit.postEvent(this.modalAppContext, new PeerEvent(this, new WakingRunnable(), 1L));
         }

         EventQueue.invokeLater(new WakingRunnable());
         this.getTreeLock().notifyAll();
      }
   }

   protected String paramString() {
      String var1 = super.paramString();
      LayoutManager var2 = this.layoutMgr;
      if (var2 != null) {
         var1 = var1 + ",layout=" + var2.getClass().getName();
      }

      return var1;
   }

   public void list(PrintStream var1, int var2) {
      super.list(var1, var2);
      int var3 = this.ncomponents;
      Component[] var4 = this.component;

      for(int var5 = 0; var5 < var3; ++var5) {
         Component var6 = var4[var5];
         if (var6 != null) {
            var6.list(var1, var2 + 1);
         }
      }

   }

   public void list(PrintWriter var1, int var2) {
      super.list(var1, var2);
      int var3 = this.ncomponents;
      Component[] var4 = this.component;

      for(int var5 = 0; var5 < var3; ++var5) {
         Component var6 = var4[var5];
         if (var6 != null) {
            var6.list(var1, var2 + 1);
         }
      }

   }

   public void setFocusTraversalKeys(int var1, Set<? extends AWTKeyStroke> var2) {
      if (var1 >= 0 && var1 < 4) {
         this.setFocusTraversalKeys_NoIDCheck(var1, var2);
      } else {
         throw new IllegalArgumentException("invalid focus traversal key identifier");
      }
   }

   public Set<AWTKeyStroke> getFocusTraversalKeys(int var1) {
      if (var1 >= 0 && var1 < 4) {
         return this.getFocusTraversalKeys_NoIDCheck(var1);
      } else {
         throw new IllegalArgumentException("invalid focus traversal key identifier");
      }
   }

   public boolean areFocusTraversalKeysSet(int var1) {
      if (var1 >= 0 && var1 < 4) {
         return this.focusTraversalKeys != null && this.focusTraversalKeys[var1] != null;
      } else {
         throw new IllegalArgumentException("invalid focus traversal key identifier");
      }
   }

   public boolean isFocusCycleRoot(Container var1) {
      return this.isFocusCycleRoot() && var1 == this ? true : super.isFocusCycleRoot(var1);
   }

   private Container findTraversalRoot() {
      Container var1 = KeyboardFocusManager.getCurrentKeyboardFocusManager().getCurrentFocusCycleRoot();
      Container var2;
      if (var1 == this) {
         var2 = this;
      } else {
         var2 = this.getFocusCycleRootAncestor();
         if (var2 == null) {
            var2 = this;
         }
      }

      if (var2 != var1) {
         KeyboardFocusManager.getCurrentKeyboardFocusManager().setGlobalCurrentFocusCycleRoot(var2);
      }

      return var2;
   }

   final boolean containsFocus() {
      synchronized(this.getTreeLock()) {
         Object var2;
         for(var2 = KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner(); var2 != null && !(var2 instanceof Window) && var2 != this; var2 = ((Component)var2).getParent()) {
         }

         return var2 == this;
      }
   }

   boolean isParentOf(Component var1) {
      synchronized(this.getTreeLock()) {
         while(var1 != null && var1 != this && !(var1 instanceof Window)) {
            var1 = ((Component)var1).getParent();
         }

         return var1 == this;
      }
   }

   void clearMostRecentFocusOwnerOnHide() {
      Object var1 = null;
      Container var2 = this;
      synchronized(this.getTreeLock()) {
         while(var2 != null && !(var2 instanceof Window)) {
            var2 = var2.getParent();
         }

         if (var2 != null) {
            for(var1 = KeyboardFocusManager.getMostRecentFocusOwner((Window)var2); var1 != null && var1 != this && !(var1 instanceof Window); var1 = ((Component)var1).getParent()) {
            }
         }
      }

      if (var1 == this) {
         KeyboardFocusManager.setMostRecentFocusOwner((Window)var2, (Component)null);
      }

      if (var2 != null) {
         Window var3 = (Window)var2;
         synchronized(this.getTreeLock()) {
            synchronized(KeyboardFocusManager.class) {
               Component var6 = var3.getTemporaryLostComponent();
               if (this.isParentOf(var6) || var6 == this) {
                  var3.setTemporaryLostComponent((Component)null);
               }
            }
         }
      }

   }

   void clearCurrentFocusCycleRootOnHide() {
      KeyboardFocusManager var1 = KeyboardFocusManager.getCurrentKeyboardFocusManager();
      Container var2 = var1.getCurrentFocusCycleRoot();
      synchronized(this.getTreeLock()) {
         while(this != var2 && !(var2 instanceof Window) && var2 != null) {
            var2 = var2.getParent();
         }
      }

      if (var2 == this) {
         var1.setGlobalCurrentFocusCycleRoot((Container)null);
      }

   }

   boolean nextFocusHelper() {
      if (!this.isFocusCycleRoot()) {
         return super.nextFocusHelper();
      } else {
         Container var1 = this.findTraversalRoot();

         Container var2;
         Container var3;
         for(var2 = this; var1 != null && (var3 = var1.getFocusCycleRootAncestor()) != null && (!var1.isShowing() || !var1.isFocusable() || !var1.isEnabled()); var1 = var3) {
            var2 = var1;
         }

         if (var1 != null) {
            FocusTraversalPolicy var4 = var1.getFocusTraversalPolicy();
            Component var5 = var4.getComponentAfter(var1, var2);
            if (var5 == null) {
               var5 = var4.getDefaultComponent(var1);
            }

            if (var5 != null) {
               return var5.requestFocus(false, Cause.TRAVERSAL_FORWARD);
            }
         }

         return false;
      }
   }

   public void transferFocusBackward() {
      if (this.isFocusCycleRoot()) {
         Container var1 = this.findTraversalRoot();

         Container var2;
         for(var2 = this; var1 != null && (!var1.isShowing() || !var1.isFocusable() || !var1.isEnabled()); var1 = ((Component)var1).getFocusCycleRootAncestor()) {
            var2 = var1;
         }

         if (var1 != null) {
            FocusTraversalPolicy var3 = var1.getFocusTraversalPolicy();
            Component var4 = var3.getComponentBefore(var1, var2);
            if (var4 == null) {
               var4 = var3.getDefaultComponent(var1);
            }

            if (var4 != null) {
               var4.requestFocus(Cause.TRAVERSAL_BACKWARD);
            }
         }
      } else {
         super.transferFocusBackward();
      }

   }

   public void setFocusTraversalPolicy(FocusTraversalPolicy var1) {
      FocusTraversalPolicy var2;
      synchronized(this) {
         var2 = this.focusTraversalPolicy;
         this.focusTraversalPolicy = var1;
      }

      this.firePropertyChange("focusTraversalPolicy", var2, var1);
   }

   public FocusTraversalPolicy getFocusTraversalPolicy() {
      if (!this.isFocusTraversalPolicyProvider() && !this.isFocusCycleRoot()) {
         return null;
      } else {
         FocusTraversalPolicy var1 = this.focusTraversalPolicy;
         if (var1 != null) {
            return var1;
         } else {
            Container var2 = this.getFocusCycleRootAncestor();
            return var2 != null ? var2.getFocusTraversalPolicy() : KeyboardFocusManager.getCurrentKeyboardFocusManager().getDefaultFocusTraversalPolicy();
         }
      }
   }

   public boolean isFocusTraversalPolicySet() {
      return this.focusTraversalPolicy != null;
   }

   public void setFocusCycleRoot(boolean var1) {
      boolean var2;
      synchronized(this) {
         var2 = this.focusCycleRoot;
         this.focusCycleRoot = var1;
      }

      this.firePropertyChange("focusCycleRoot", var2, var1);
   }

   public boolean isFocusCycleRoot() {
      return this.focusCycleRoot;
   }

   public final void setFocusTraversalPolicyProvider(boolean var1) {
      boolean var2;
      synchronized(this) {
         var2 = this.focusTraversalPolicyProvider;
         this.focusTraversalPolicyProvider = var1;
      }

      this.firePropertyChange("focusTraversalPolicyProvider", var2, var1);
   }

   public final boolean isFocusTraversalPolicyProvider() {
      return this.focusTraversalPolicyProvider;
   }

   public void transferFocusDownCycle() {
      if (this.isFocusCycleRoot()) {
         KeyboardFocusManager.getCurrentKeyboardFocusManager().setGlobalCurrentFocusCycleRoot(this);
         Component var1 = this.getFocusTraversalPolicy().getDefaultComponent(this);
         if (var1 != null) {
            var1.requestFocus(Cause.TRAVERSAL_DOWN);
         }
      }

   }

   void preProcessKeyEvent(KeyEvent var1) {
      Container var2 = this.parent;
      if (var2 != null) {
         var2.preProcessKeyEvent(var1);
      }

   }

   void postProcessKeyEvent(KeyEvent var1) {
      Container var2 = this.parent;
      if (var2 != null) {
         var2.postProcessKeyEvent(var1);
      }

   }

   boolean postsOldMouseEvents() {
      return true;
   }

   public void applyComponentOrientation(ComponentOrientation var1) {
      super.applyComponentOrientation(var1);

      for(int var2 = 0; var2 < this.ncomponents; ++var2) {
         this.component[var2].applyComponentOrientation(var1);
      }

   }

   public void addPropertyChangeListener(PropertyChangeListener var1) {
      super.addPropertyChangeListener(var1);
   }

   public void addPropertyChangeListener(String var1, PropertyChangeListener var2) {
      super.addPropertyChangeListener(var1, var2);
   }

   private void writeObject(ObjectOutputStream var1) throws IOException {
      ObjectOutputStream.PutField var2 = var1.putFields();
      var2.put("ncomponents", this.ncomponents);
      var2.put("component", this.component);
      var2.put("layoutMgr", this.layoutMgr);
      var2.put("dispatcher", this.dispatcher);
      var2.put("maxSize", this.maxSize);
      var2.put("focusCycleRoot", this.focusCycleRoot);
      var2.put("containerSerializedDataVersion", this.containerSerializedDataVersion);
      var2.put("focusTraversalPolicyProvider", this.focusTraversalPolicyProvider);
      var1.writeFields();
      AWTEventMulticaster.save(var1, "containerL", this.containerListener);
      var1.writeObject((Object)null);
      if (this.focusTraversalPolicy instanceof Serializable) {
         var1.writeObject(this.focusTraversalPolicy);
      } else {
         var1.writeObject((Object)null);
      }

   }

   private void readObject(ObjectInputStream var1) throws ClassNotFoundException, IOException {
      ObjectInputStream.GetField var2 = var1.readFields();
      this.ncomponents = var2.get("ncomponents", 0);
      this.component = (Component[])var2.get("component", new Component[0]);
      this.layoutMgr = (LayoutManager)var2.get("layoutMgr", (Object)null);
      this.dispatcher = (LightweightDispatcher)var2.get("dispatcher", (Object)null);
      if (this.maxSize == null) {
         this.maxSize = (Dimension)var2.get("maxSize", (Object)null);
      }

      this.focusCycleRoot = var2.get("focusCycleRoot", false);
      this.containerSerializedDataVersion = var2.get("containerSerializedDataVersion", 1);
      this.focusTraversalPolicyProvider = var2.get("focusTraversalPolicyProvider", false);
      Component[] var3 = this.component;

      for(int var4 = 0; var4 < this.ncomponents; ++var4) {
         var3[var4].parent = this;
         this.adjustListeningChildren(32768L, var3[var4].numListening(32768L));
         this.adjustListeningChildren(65536L, var3[var4].numListening(65536L));
         this.adjustDescendants(var3[var4].countHierarchyMembers());
      }

      Object var7;
      while(null != (var7 = var1.readObject())) {
         String var5 = ((String)var7).intern();
         if ("containerL" == var5) {
            this.addContainerListener((ContainerListener)var1.readObject());
         } else {
            var1.readObject();
         }
      }

      try {
         Object var8 = var1.readObject();
         if (var8 instanceof FocusTraversalPolicy) {
            this.focusTraversalPolicy = (FocusTraversalPolicy)var8;
         }
      } catch (OptionalDataException var6) {
         if (!var6.eof) {
            throw var6;
         }
      }

   }

   Accessible getAccessibleAt(Point var1) {
      synchronized(this.getTreeLock()) {
         if (this instanceof Accessible) {
            Accessible var12 = (Accessible)this;
            AccessibleContext var14 = var12.getAccessibleContext();
            if (var14 != null) {
               int var17 = var14.getAccessibleChildrenCount();

               for(int var8 = 0; var8 < var17; ++var8) {
                  var12 = var14.getAccessibleChild(var8);
                  if (var12 != null) {
                     var14 = var12.getAccessibleContext();
                     if (var14 != null) {
                        AccessibleComponent var15 = var14.getAccessibleComponent();
                        if (var15 != null && var15.isShowing()) {
                           Point var16 = var15.getLocation();
                           Point var9 = new Point(var1.x - var16.x, var1.y - var16.y);
                           if (var15.contains(var9)) {
                              return var12;
                           }
                        }
                     }
                  }
               }
            }

            return (Accessible)this;
         } else {
            Object var3 = this;
            if (!this.contains(var1.x, var1.y)) {
               var3 = null;
            } else {
               int var4 = this.getComponentCount();

               for(int var5 = 0; var5 < var4; ++var5) {
                  Component var6 = this.getComponent(var5);
                  if (var6 != null && var6.isShowing()) {
                     Point var7 = var6.getLocation();
                     if (var6.contains(var1.x - var7.x, var1.y - var7.y)) {
                        var3 = var6;
                     }
                  }
               }
            }

            return var3 instanceof Accessible ? (Accessible)var3 : null;
         }
      }
   }

   int getAccessibleChildrenCount() {
      synchronized(this.getTreeLock()) {
         int var2 = 0;
         Component[] var3 = this.getComponents();

         for(int var4 = 0; var4 < var3.length; ++var4) {
            if (var3[var4] instanceof Accessible) {
               ++var2;
            }
         }

         return var2;
      }
   }

   Accessible getAccessibleChild(int var1) {
      synchronized(this.getTreeLock()) {
         Component[] var3 = this.getComponents();
         int var4 = 0;

         for(int var5 = 0; var5 < var3.length; ++var5) {
            if (var3[var5] instanceof Accessible) {
               if (var4 == var1) {
                  return (Accessible)var3[var5];
               }

               ++var4;
            }
         }

         return null;
      }
   }

   static {
      serialPersistentFields = new ObjectStreamField[]{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)};
      Toolkit.loadLibraries();
      if (!GraphicsEnvironment.isHeadless()) {
         initIDs();
      }

   }
}