home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 June / CHIPHEFT062001.ISO / browser / nc32lyc / comm.z / java40.jar / java / awt / Container.class (.txt) < prev    next >
Encoding:
Java Class File  |  2000-08-15  |  13.8 KB  |  881 lines
  1. package java.awt;
  2.  
  3. import java.awt.event.ContainerEvent;
  4. import java.awt.event.ContainerListener;
  5. import java.awt.event.KeyEvent;
  6. import java.awt.peer.ContainerPeer;
  7. import java.awt.peer.LightweightPeer;
  8. import java.io.IOException;
  9. import java.io.ObjectInputStream;
  10. import java.io.ObjectOutputStream;
  11. import java.io.PrintStream;
  12. import java.io.PrintWriter;
  13.  
  14. public abstract class Container extends Component {
  15.    int ncomponents;
  16.    Component[] component = new Component[4];
  17.    LayoutManager layoutMgr;
  18.    private LightweightDispatcher dispatcher;
  19.    private Dimension maxSize;
  20.    transient ContainerListener containerListener;
  21.    private static final long serialVersionUID = 4613797578919906343L;
  22.    private int containerSerializedDataVersion = 1;
  23.  
  24.    protected Container() {
  25.    }
  26.  
  27.    public int getComponentCount() {
  28.       return this.countComponents();
  29.    }
  30.  
  31.    public int countComponents() {
  32.       return this.ncomponents;
  33.    }
  34.  
  35.    public Component getComponent(int var1) {
  36.       Object var3 = Component.LOCK;
  37.       synchronized(var3){}
  38.  
  39.       Component var2;
  40.       try {
  41.          if (var1 < 0 || var1 >= this.ncomponents) {
  42.             throw new ArrayIndexOutOfBoundsException("No such child: " + var1);
  43.          }
  44.  
  45.          var2 = this.component[var1];
  46.       } catch (Throwable var6) {
  47.          throw var6;
  48.       }
  49.  
  50.       return var2;
  51.    }
  52.  
  53.    public Component[] getComponents() {
  54.       Object var2 = Component.LOCK;
  55.       synchronized(var2){}
  56.  
  57.       Component[] var1;
  58.       try {
  59.          Component[] var4 = new Component[this.ncomponents];
  60.          System.arraycopy(this.component, 0, var4, 0, this.ncomponents);
  61.          var1 = var4;
  62.       } catch (Throwable var6) {
  63.          throw var6;
  64.       }
  65.  
  66.       return var1;
  67.    }
  68.  
  69.    public Insets getInsets() {
  70.       return this.insets();
  71.    }
  72.  
  73.    public Insets insets() {
  74.       if (super.peer != null && super.peer instanceof ContainerPeer) {
  75.          ContainerPeer var1 = (ContainerPeer)super.peer;
  76.          return var1.insets();
  77.       } else {
  78.          return new Insets(0, 0, 0, 0);
  79.       }
  80.    }
  81.  
  82.    public Component add(Component var1) {
  83.       this.addImpl(var1, (Object)null, -1);
  84.       return var1;
  85.    }
  86.  
  87.    public Component add(String var1, Component var2) {
  88.       this.addImpl(var2, var1, -1);
  89.       return var2;
  90.    }
  91.  
  92.    public Component add(Component var1, int var2) {
  93.       this.addImpl(var1, (Object)null, var2);
  94.       return var1;
  95.    }
  96.  
  97.    public void add(Component var1, Object var2) {
  98.       this.addImpl(var1, var2, -1);
  99.    }
  100.  
  101.    public void add(Component var1, Object var2, int var3) {
  102.       this.addImpl(var1, var2, var3);
  103.    }
  104.  
  105.    protected void addImpl(Component var1, Object var2, int var3) {
  106.       Object var4 = Component.LOCK;
  107.       synchronized(var4){}
  108.  
  109.       try {
  110.          if (var3 > this.ncomponents || var3 < 0 && var3 != -1) {
  111.             throw new IllegalArgumentException("illegal component position");
  112.          }
  113.  
  114.          if (var1 instanceof Container) {
  115.             for(Container var6 = this; var6 != null; var6 = var6.parent) {
  116.                if (var6 == var1) {
  117.                   throw new IllegalArgumentException("adding container's parent to itself");
  118.                }
  119.             }
  120.          }
  121.  
  122.          if (var1 instanceof Window) {
  123.             throw new IllegalArgumentException("adding a window to a container");
  124.          }
  125.  
  126.          if (var1.parent != null) {
  127.             var1.parent.remove(var1);
  128.          }
  129.  
  130.          if (this.ncomponents == this.component.length) {
  131.             Component[] var9 = new Component[this.ncomponents * 2];
  132.             System.arraycopy(this.component, 0, var9, 0, this.ncomponents);
  133.             this.component = var9;
  134.          }
  135.  
  136.          if (var3 != -1 && var3 != this.ncomponents) {
  137.             System.arraycopy(this.component, var3, this.component, var3 + 1, this.ncomponents - var3);
  138.             this.component[var3] = var1;
  139.             ++this.ncomponents;
  140.          } else {
  141.             this.component[this.ncomponents++] = var1;
  142.          }
  143.  
  144.          var1.parent = this;
  145.          if (super.valid) {
  146.             this.invalidate();
  147.          }
  148.  
  149.          if (super.peer != null) {
  150.             var1.addNotify();
  151.          }
  152.  
  153.          if (this.layoutMgr != null) {
  154.             if (this.layoutMgr instanceof LayoutManager2) {
  155.                ((LayoutManager2)this.layoutMgr).addLayoutComponent(var1, var2);
  156.             } else if (var2 instanceof String) {
  157.                this.layoutMgr.addLayoutComponent((String)var2, var1);
  158.             }
  159.          }
  160.  
  161.          if (this.containerListener != null || (super.eventMask & 2L) != 0L) {
  162.             ContainerEvent var10 = new ContainerEvent(this, 300, var1);
  163.             this.processEvent(var10);
  164.          }
  165.       } catch (Throwable var8) {
  166.          throw var8;
  167.       }
  168.  
  169.    }
  170.  
  171.    public void remove(int var1) {
  172.       Object var2 = Component.LOCK;
  173.       synchronized(var2){}
  174.  
  175.       try {
  176.          Component var4 = this.component[var1];
  177.          if (super.peer != null) {
  178.             var4.removeNotify();
  179.          }
  180.  
  181.          if (this.layoutMgr != null) {
  182.             this.layoutMgr.removeLayoutComponent(var4);
  183.          }
  184.  
  185.          var4.parent = null;
  186.          System.arraycopy(this.component, var1 + 1, this.component, var1, this.ncomponents - var1 - 1);
  187.          this.component[--this.ncomponents] = null;
  188.          if (super.valid) {
  189.             this.invalidate();
  190.          }
  191.  
  192.          if (this.containerListener != null || (super.eventMask & 2L) != 0L) {
  193.             ContainerEvent var5 = new ContainerEvent(this, 301, var4);
  194.             this.processEvent(var5);
  195.          }
  196.       } catch (Throwable var7) {
  197.          throw var7;
  198.       }
  199.  
  200.    }
  201.  
  202.    public void remove(Component var1) {
  203.       Object var2 = Component.LOCK;
  204.       synchronized(var2){}
  205.  
  206.       try {
  207.          if (var1.parent == this) {
  208.             Component[] var4 = this.component;
  209.             int var5 = this.ncomponents;
  210.  
  211.             while(true) {
  212.                --var5;
  213.                if (var5 < 0) {
  214.                   break;
  215.                }
  216.  
  217.                if (var4[var5] == var1) {
  218.                   this.remove(var5);
  219.                }
  220.             }
  221.          }
  222.       } catch (Throwable var7) {
  223.          throw var7;
  224.       }
  225.  
  226.    }
  227.  
  228.    public void removeAll() {
  229.       Object var1 = Component.LOCK;
  230.       synchronized(var1){}
  231.  
  232.       try {
  233.          while(this.ncomponents > 0) {
  234.             Component var3 = this.component[--this.ncomponents];
  235.             this.component[this.ncomponents] = null;
  236.             if (super.peer != null) {
  237.                var3.removeNotify();
  238.             }
  239.  
  240.             if (this.layoutMgr != null) {
  241.                this.layoutMgr.removeLayoutComponent(var3);
  242.             }
  243.  
  244.             var3.parent = null;
  245.             if (this.containerListener != null || (super.eventMask & 2L) != 0L) {
  246.                ContainerEvent var4 = new ContainerEvent(this, 301, var3);
  247.                this.processEvent(var4);
  248.             }
  249.          }
  250.  
  251.          if (super.valid) {
  252.             this.invalidate();
  253.          }
  254.       } catch (Throwable var6) {
  255.          throw var6;
  256.       }
  257.  
  258.    }
  259.  
  260.    public LayoutManager getLayout() {
  261.       return this.layoutMgr;
  262.    }
  263.  
  264.    public void setLayout(LayoutManager var1) {
  265.       this.layoutMgr = var1;
  266.       if (super.valid) {
  267.          this.invalidate();
  268.       }
  269.  
  270.    }
  271.  
  272.    public void doLayout() {
  273.       this.layout();
  274.    }
  275.  
  276.    public void layout() {
  277.       LayoutManager var1 = this.layoutMgr;
  278.       if (var1 != null) {
  279.          var1.layoutContainer(this);
  280.       }
  281.  
  282.    }
  283.  
  284.    public void invalidate() {
  285.       if (this.layoutMgr instanceof LayoutManager2) {
  286.          LayoutManager2 var1 = (LayoutManager2)this.layoutMgr;
  287.          var1.invalidateLayout(this);
  288.       }
  289.  
  290.       super.invalidate();
  291.    }
  292.  
  293.    public void validate() {
  294.       if (!super.valid) {
  295.          Object var1 = Component.LOCK;
  296.          synchronized(var1){}
  297.  
  298.          try {
  299.             if (!super.valid && super.peer != null) {
  300.                ((Component)this).getCursor();
  301.                ContainerPeer var3 = null;
  302.                if (super.peer instanceof ContainerPeer) {
  303.                   var3 = (ContainerPeer)super.peer;
  304.                }
  305.  
  306.                if (var3 != null) {
  307.                   var3.beginValidate();
  308.                }
  309.  
  310.                this.validateTree();
  311.                super.valid = true;
  312.                if (var3 != null) {
  313.                   var3.endValidate();
  314.                }
  315.             }
  316.          } catch (Throwable var5) {
  317.             throw var5;
  318.          }
  319.  
  320.       }
  321.    }
  322.  
  323.    protected void validateTree() {
  324.       if (!super.valid) {
  325.          this.doLayout();
  326.          Component[] var1 = this.component;
  327.  
  328.          for(int var2 = 0; var2 < this.ncomponents; ++var2) {
  329.             Component var3 = var1[var2];
  330.             if (var3 instanceof Container && !(var3 instanceof Window) && !var3.valid) {
  331.                ((Container)var3).validateTree();
  332.             } else {
  333.                var3.validate();
  334.             }
  335.          }
  336.       }
  337.  
  338.       super.valid = true;
  339.    }
  340.  
  341.    public Dimension getPreferredSize() {
  342.       return this.preferredSize();
  343.    }
  344.  
  345.    public Dimension preferredSize() {
  346.       Dimension var1 = super.prefSize;
  347.       if (var1 != null && ((Component)this).isValid()) {
  348.          return var1;
  349.       } else {
  350.          Object var3 = Component.LOCK;
  351.          synchronized(var3){}
  352.  
  353.          Dimension var2;
  354.          try {
  355.             super.prefSize = this.layoutMgr != null ? this.layoutMgr.preferredLayoutSize(this) : super.preferredSize();
  356.             var2 = super.prefSize;
  357.          } catch (Throwable var6) {
  358.             throw var6;
  359.          }
  360.  
  361.          return var2;
  362.       }
  363.    }
  364.  
  365.    public Dimension getMinimumSize() {
  366.       return this.minimumSize();
  367.    }
  368.  
  369.    public Dimension minimumSize() {
  370.       Dimension var1 = super.minSize;
  371.       if (var1 != null && ((Component)this).isValid()) {
  372.          return var1;
  373.       } else {
  374.          Object var3 = Component.LOCK;
  375.          synchronized(var3){}
  376.  
  377.          Dimension var2;
  378.          try {
  379.             super.minSize = this.layoutMgr != null ? this.layoutMgr.minimumLayoutSize(this) : super.minimumSize();
  380.             var2 = super.minSize;
  381.          } catch (Throwable var6) {
  382.             throw var6;
  383.          }
  384.  
  385.          return var2;
  386.       }
  387.    }
  388.  
  389.    public Dimension getMaximumSize() {
  390.       Dimension var1 = this.maxSize;
  391.       if (var1 != null && ((Component)this).isValid()) {
  392.          return var1;
  393.       } else {
  394.          if (this.layoutMgr instanceof LayoutManager2) {
  395.             Object var2 = Component.LOCK;
  396.             synchronized(var2){}
  397.  
  398.             try {
  399.                LayoutManager2 var4 = (LayoutManager2)this.layoutMgr;
  400.                this.maxSize = var4.maximumLayoutSize(this);
  401.             } catch (Throwable var6) {
  402.                throw var6;
  403.             }
  404.          } else {
  405.             this.maxSize = super.getMaximumSize();
  406.          }
  407.  
  408.          return this.maxSize;
  409.       }
  410.    }
  411.  
  412.    public float getAlignmentX() {
  413.       float var1;
  414.       if (this.layoutMgr instanceof LayoutManager2) {
  415.          Object var2 = Component.LOCK;
  416.          synchronized(var2){}
  417.  
  418.          try {
  419.             LayoutManager2 var4 = (LayoutManager2)this.layoutMgr;
  420.             var1 = var4.getLayoutAlignmentX(this);
  421.          } catch (Throwable var6) {
  422.             throw var6;
  423.          }
  424.       } else {
  425.          var1 = super.getAlignmentX();
  426.       }
  427.  
  428.       return var1;
  429.    }
  430.  
  431.    public float getAlignmentY() {
  432.       float var1;
  433.       if (this.layoutMgr instanceof LayoutManager2) {
  434.          Object var2 = Component.LOCK;
  435.          synchronized(var2){}
  436.  
  437.          try {
  438.             LayoutManager2 var4 = (LayoutManager2)this.layoutMgr;
  439.             var1 = var4.getLayoutAlignmentY(this);
  440.          } catch (Throwable var6) {
  441.             throw var6;
  442.          }
  443.       } else {
  444.          var1 = super.getAlignmentY();
  445.       }
  446.  
  447.       return var1;
  448.    }
  449.  
  450.    public void paint(Graphics var1) {
  451.       if (((Component)this).isShowing()) {
  452.          int var2 = this.ncomponents;
  453.          Component[] var3 = this.component;
  454.          Rectangle var4 = var1.getClipRect();
  455.  
  456.          for(int var5 = var2 - 1; var5 >= 0; --var5) {
  457.             Component var6 = var3[var5];
  458.             if (var6 != null && var6.peer instanceof LightweightPeer && var6.visible) {
  459.                Rectangle var7 = var6.getBounds();
  460.                if (var4 == null || var7.intersects(var4)) {
  461.                   Graphics var8 = var1.create(var7.x, var7.y, var7.width, var7.height);
  462.  
  463.                   try {
  464.                      var6.paint(var8);
  465.                   } finally {
  466.                      var8.dispose();
  467.                   }
  468.                }
  469.             }
  470.          }
  471.       }
  472.  
  473.    }
  474.  
  475.    public void update(Graphics var1) {
  476.       if (((Component)this).isShowing()) {
  477.          super.update(var1);
  478.          int var2 = this.ncomponents;
  479.          Component[] var3 = this.component;
  480.          Rectangle var4 = var1.getClipRect();
  481.  
  482.          for(int var5 = var2 - 1; var5 >= 0; --var5) {
  483.             Component var6 = var3[var5];
  484.             if (var6 != null && var6.peer instanceof LightweightPeer && var6.visible) {
  485.                Rectangle var7 = var6.getBounds();
  486.                if (var4 == null || var7.intersects(var4)) {
  487.                   Graphics var8 = var1.create(var7.x, var7.y, var7.width, var7.height);
  488.  
  489.                   try {
  490.                      var6.update(var8);
  491.                   } finally {
  492.                      var8.dispose();
  493.                   }
  494.                }
  495.             }
  496.          }
  497.       }
  498.  
  499.    }
  500.  
  501.    public void print(Graphics var1) {
  502.       super.print(var1);
  503.       int var2 = this.ncomponents;
  504.       Component[] var3 = this.component;
  505.       Rectangle var4 = var1.getClipRect();
  506.  
  507.       for(int var5 = var2 - 1; var5 >= 0; --var5) {
  508.          Component var6 = var3[var5];
  509.          if (var6 != null && var6.peer instanceof LightweightPeer) {
  510.             Rectangle var7 = var6.getBounds();
  511.             if (var7.intersects(var4)) {
  512.                Graphics var8 = var1.create(var7.x, var7.y, var7.width, var7.height);
  513.  
  514.                try {
  515.                   var6.print(var8);
  516.                } finally {
  517.                   var8.dispose();
  518.                }
  519.             }
  520.          }
  521.       }
  522.  
  523.    }
  524.  
  525.    public void paintComponents(Graphics var1) {
  526.       int var2 = this.ncomponents;
  527.       Component[] var3 = this.component;
  528.  
  529.       for(int var4 = var2 - 1; var4 >= 0; --var4) {
  530.          Component var5 = var3[var4];
  531.          if (var5 != null) {
  532.             Graphics var6 = var5.getGraphics();
  533.             Rectangle var7 = var1.getClipRect();
  534.             if (var7 != null) {
  535.                Rectangle var8 = var5.getBounds();
  536.                if (!var8.intersects(var7)) {
  537.                   continue;
  538.                }
  539.  
  540.                Rectangle var9 = var8.intersection(var7);
  541.                var9.translate(-var8.x, -var8.y);
  542.                var6.clipRect(var9.x, var9.y, var9.width, var9.height);
  543.             }
  544.  
  545.             try {
  546.                var5.paintAll(var6);
  547.             } finally {
  548.                var6.dispose();
  549.             }
  550.          }
  551.       }
  552.  
  553.    }
  554.  
  555.    public void printComponents(Graphics var1) {
  556.       int var2 = this.ncomponents;
  557.       Component[] var3 = this.component;
  558.  
  559.       for(int var4 = 0; var4 < var2; ++var4) {
  560.          Component var5 = var3[var4];
  561.          if (var5 != null) {
  562.             Graphics var6 = var1.create(var5.x, var5.y, var5.width, var5.height);
  563.  
  564.             try {
  565.                var5.printAll(var6);
  566.             } finally {
  567.                var6.dispose();
  568.             }
  569.          }
  570.       }
  571.  
  572.    }
  573.  
  574.    public synchronized void addContainerListener(ContainerListener var1) {
  575.       this.containerListener = AWTEventMulticaster.add(this.containerListener, var1);
  576.       super.newEventsOnly = true;
  577.    }
  578.  
  579.    public void removeContainerListener(ContainerListener var1) {
  580.       this.containerListener = AWTEventMulticaster.remove(this.containerListener, var1);
  581.    }
  582.  
  583.    boolean eventEnabled(AWTEvent var1) {
  584.       int var2 = var1.getID();
  585.       if (var2 != 300 && var2 != 301) {
  586.          return super.eventEnabled(var1);
  587.       } else {
  588.          return (super.eventMask & 2L) != 0L || this.containerListener != null;
  589.       }
  590.    }
  591.  
  592.    protected void processEvent(AWTEvent var1) {
  593.       if (var1 instanceof ContainerEvent) {
  594.          this.processContainerEvent((ContainerEvent)var1);
  595.       } else {
  596.          super.processEvent(var1);
  597.       }
  598.    }
  599.  
  600.    protected void processContainerEvent(ContainerEvent var1) {
  601.       if (this.containerListener != null) {
  602.          switch (((AWTEvent)var1).getID()) {
  603.             case 300:
  604.                this.containerListener.componentAdded(var1);
  605.                return;
  606.             case 301:
  607.                this.containerListener.componentRemoved(var1);
  608.                return;
  609.          }
  610.       }
  611.  
  612.    }
  613.  
  614.    void dispatchEventImpl(AWTEvent var1) {
  615.       if (this.dispatcher != null && this.dispatcher.dispatchEvent(var1)) {
  616.          var1.consume();
  617.          if (super.peer != null) {
  618.             super.peer.handleEvent(var1);
  619.          }
  620.  
  621.       } else {
  622.          super.dispatchEventImpl(var1);
  623.       }
  624.    }
  625.  
  626.    Component getMouseEventTarget(int var1, int var2) {
  627.       int var3 = this.ncomponents;
  628.       Component[] var4 = this.component;
  629.  
  630.       for(int var5 = 0; var5 < var3; ++var5) {
  631.          Component var6 = var4[var5];
  632.          if (var6 != null && var6.contains(var1 - var6.x, var2 - var6.y) && var6.peer instanceof LightweightPeer && var6.visible) {
  633.             if (var6 instanceof Container) {
  634.                Container var7 = (Container)var6;
  635.                Component var8 = var7.getMouseEventTarget(var1 - var7.x, var2 - var7.y);
  636.                if (var8 != null) {
  637.                   return var8;
  638.                }
  639.             } else if (var6.mouseListener != null || (var6.eventMask & 16L) != 0L || var6.mouseMotionListener != null || (var6.eventMask & 32L) != 0L) {
  640.                return var6;
  641.             }
  642.          }
  643.       }
  644.  
  645.       if ((super.mouseListener != null || (super.eventMask & 16L) != 0L || super.mouseMotionListener != null || (super.eventMask & 32L) != 0L) && super.peer instanceof LightweightPeer) {
  646.          return this;
  647.       } else {
  648.          return null;
  649.       }
  650.    }
  651.  
  652.    void proxyEnableEvents(long var1) {
  653.       if (super.peer instanceof LightweightPeer) {
  654.          super.parent.proxyEnableEvents(var1);
  655.       } else {
  656.          if (this.dispatcher != null) {
  657.             this.dispatcher.enableEvents(var1);
  658.          }
  659.  
  660.       }
  661.    }
  662.  
  663.    Window getWindow() {
  664.       Container var1;
  665.       for(var1 = this; var1 != null && !(var1 instanceof Window); var1 = ((Component)var1).getParent()) {
  666.       }
  667.  
  668.       return (Window)var1;
  669.    }
  670.  
  671.    void proxyRequestFocus(Component var1) {
  672.       if (super.peer instanceof LightweightPeer) {
  673.          super.parent.proxyRequestFocus(var1);
  674.       } else {
  675.          if (this.dispatcher.setFocusRequest(var1)) {
  676.             super.peer.requestFocus();
  677.             Toolkit.getEventQueue().changeKeyEventFocus(this);
  678.          }
  679.  
  680.       }
  681.    }
  682.  
  683.    public void deliverEvent(Event var1) {
  684.       Component var2 = this.getComponentAt(var1.x, var1.y);
  685.       if (var2 != null && var2 != this) {
  686.          var1.translate(-var2.x, -var2.y);
  687.          var2.deliverEvent(var1);
  688.       } else {
  689.          ((Component)this).postEvent(var1);
  690.       }
  691.    }
  692.  
  693.    public Component getComponentAt(int var1, int var2) {
  694.       return this.locate(var1, var2);
  695.    }
  696.  
  697.    public Component locate(int var1, int var2) {
  698.       if (!((Component)this).contains(var1, var2)) {
  699.          return null;
  700.       } else {
  701.          int var3 = this.ncomponents;
  702.          Component[] var4 = this.component;
  703.  
  704.          for(int var5 = 0; var5 < var3; ++var5) {
  705.             Component var6 = var4[var5];
  706.             if (var6 != null && var6.contains(var1 - var6.x, var2 - var6.y)) {
  707.                return var6;
  708.             }
  709.          }
  710.  
  711.          return this;
  712.       }
  713.    }
  714.  
  715.    public Component getComponentAt(Point var1) {
  716.       return this.getComponentAt(var1.x, var1.y);
  717.    }
  718.  
  719.    public void addNotify() {
  720.       super.addNotify();
  721.       if (!(super.peer instanceof LightweightPeer)) {
  722.          this.dispatcher = new LightweightDispatcher(this);
  723.       }
  724.  
  725.       Object var1 = Component.LOCK;
  726.       synchronized(var1){}
  727.  
  728.       try {
  729.          int var3 = this.ncomponents;
  730.          Component[] var4 = this.component;
  731.  
  732.          for(int var5 = 0; var5 < var3; ++var5) {
  733.             var4[var5].addNotify();
  734.          }
  735.       } catch (Throwable var7) {
  736.          throw var7;
  737.       }
  738.  
  739.    }
  740.  
  741.    public void removeNotify() {
  742.       Object var1 = Component.LOCK;
  743.       synchronized(var1){}
  744.  
  745.       try {
  746.          int var3 = this.ncomponents;
  747.          Component[] var4 = this.component;
  748.  
  749.          for(int var5 = 0; var5 < var3; ++var5) {
  750.             var4[var5].removeNotify();
  751.          }
  752.  
  753.          super.removeNotify();
  754.       } catch (Throwable var7) {
  755.          throw var7;
  756.       }
  757.  
  758.    }
  759.  
  760.    public boolean isAncestorOf(Component var1) {
  761.       Container var2;
  762.       if (var1 != null && (var2 = var1.getParent()) != null) {
  763.          while(var2 != null) {
  764.             if (var2 == this) {
  765.                return true;
  766.             }
  767.  
  768.             var2 = ((Component)var2).getParent();
  769.          }
  770.  
  771.          return false;
  772.       } else {
  773.          return false;
  774.       }
  775.    }
  776.  
  777.    protected String paramString() {
  778.       String var1 = super.paramString();
  779.       LayoutManager var2 = this.layoutMgr;
  780.       if (var2 != null) {
  781.          var1 = var1 + ",layout=" + var2.getClass().getName();
  782.       }
  783.  
  784.       return var1;
  785.    }
  786.  
  787.    public void list(PrintStream var1, int var2) {
  788.       super.list(var1, var2);
  789.       int var3 = this.ncomponents;
  790.       Component[] var4 = this.component;
  791.  
  792.       for(int var5 = 0; var5 < var3; ++var5) {
  793.          Component var6 = var4[var5];
  794.          if (var6 != null) {
  795.             var6.list(var1, var2 + 1);
  796.          }
  797.       }
  798.  
  799.    }
  800.  
  801.    public void list(PrintWriter var1, int var2) {
  802.       super.list(var1, var2);
  803.       int var3 = this.ncomponents;
  804.       Component[] var4 = this.component;
  805.  
  806.       for(int var5 = 0; var5 < var3; ++var5) {
  807.          Component var6 = var4[var5];
  808.          if (var6 != null) {
  809.             var6.list(var1, var2 + 1);
  810.          }
  811.       }
  812.  
  813.    }
  814.  
  815.    void setFocusOwner(Component var1) {
  816.       Container var2 = super.parent;
  817.       if (var2 != null) {
  818.          var2.setFocusOwner(var1);
  819.       }
  820.  
  821.    }
  822.  
  823.    void preProcessKeyEvent(KeyEvent var1) {
  824.       Container var2 = super.parent;
  825.       if (var2 != null) {
  826.          var2.preProcessKeyEvent(var1);
  827.       }
  828.  
  829.    }
  830.  
  831.    void postProcessKeyEvent(KeyEvent var1) {
  832.       Container var2 = super.parent;
  833.       if (var2 != null) {
  834.          var2.postProcessKeyEvent(var1);
  835.       }
  836.  
  837.    }
  838.  
  839.    void transferFocus(Component var1) {
  840.       this.nextFocus(var1);
  841.    }
  842.  
  843.    boolean postsOldMouseEvents() {
  844.       return true;
  845.    }
  846.  
  847.    void nextFocus(Component var1) {
  848.       Container var2 = super.parent;
  849.       if (var2 != null) {
  850.          var2.transferFocus(var1);
  851.       }
  852.  
  853.    }
  854.  
  855.    private void writeObject(ObjectOutputStream var1) throws IOException {
  856.       var1.defaultWriteObject();
  857.       AWTEventMulticaster.save(var1, "containerL", this.containerListener);
  858.       var1.writeObject((Object)null);
  859.    }
  860.  
  861.    private void readObject(ObjectInputStream var1) throws ClassNotFoundException, IOException {
  862.       var1.defaultReadObject();
  863.       Component[] var2 = this.component;
  864.  
  865.       for(int var3 = 0; var3 < this.ncomponents; ++var3) {
  866.          var2[var3].parent = this;
  867.       }
  868.  
  869.       Object var4;
  870.       while((var4 = var1.readObject()) != null) {
  871.          String var5 = ((String)var4).intern();
  872.          if (var5 == "containerL") {
  873.             this.addContainerListener((ContainerListener)var1.readObject());
  874.          } else {
  875.             var1.readObject();
  876.          }
  877.       }
  878.  
  879.    }
  880. }
  881.