home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1995 November / PCWK1195.iso / inne / win95 / sieciowe / hotja32.lzh / hotjava / classsrc / awt / container.java < prev    next >
Text File  |  1995-08-11  |  6KB  |  245 lines
  1. /*
  2.  * @(#)Container.java    1.17 95/02/16 Arthur van Hoff
  3.  *
  4.  * Copyright (c) 1994 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * Permission to use, copy, modify, and distribute this software
  7.  * and its documentation for NON-COMMERCIAL purposes and without
  8.  * fee is hereby granted provided that this copyright notice
  9.  * appears in all copies. Please refer to the file "copyright.html"
  10.  * for further important copyright and licensing information.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF
  13.  * THE SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  14.  * TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  15.  * PARTICULAR PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR
  16.  * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
  17.  * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES.
  18.  */
  19. package awt;
  20.  
  21. import java.util.*;
  22.  
  23. /**
  24.  * A container object is a component that can contain other
  25.  * components. Examples are windows, and frames.
  26.  *
  27.  * @version 1.17 16 Feb 1995
  28.  * @author Arthur van Hoff, Sami Shaio
  29.  */
  30. public class Container extends Component {
  31.     /**
  32.      * The window server associated with this component.
  33.      */
  34.     public WServer    wServer;
  35.  
  36.     /**
  37.      * The member objects (only nmembers are used)
  38.      */
  39.     public ChildList children = new ChildList();
  40.  
  41.     /**
  42.      * A layout object (or 0). Used to layout the
  43.      * member object when the container is untidy.
  44.      */
  45.     public ContainerLayout theLayout;
  46.  
  47.     /**
  48.      * The insets (distances from the sides) of this
  49.      * container.
  50.      */
  51.     public int insets[] = new int[4];
  52.  
  53.     /**
  54.      * Contructor
  55.      */
  56.     public Container(Container pParent, String pName) {
  57.     super(pParent, pName);
  58.     setInsets(5,5,5,5);
  59.     }
  60.  
  61.     /**
  62.      * Add a named child to the container (at the end,
  63.      * front most).
  64.      */
  65.     public void addChild(Layoutable c, String name) {
  66.     children.addChild(c, name);
  67.     }
  68.  
  69.     /**
  70.      * Add an unnamed child to the container.
  71.      */
  72.     public void addChild(Layoutable c) {
  73.     children.addChild(c, null);
  74.     }
  75.  
  76.     /**
  77.      * Find a member component by name.
  78.      */
  79.     public Layoutable getChild(String pName) {
  80.     return children.getChild(pName);
  81.     }
  82.  
  83.     /**
  84.      * Find a member component by position.
  85.      */
  86.     public Layoutable getChild(int pos) {
  87.     return children.getChild(pos);
  88.     }
  89.  
  90.     /** 
  91.      * Return the number of children in this container.
  92.      */
  93.     public int nChildren() {
  94.     return children.length();
  95.     }
  96.  
  97.     /**
  98.      * Dispose of the container and its members, releasing
  99.      * all of its resources.
  100.      */
  101.     public void dispose() {
  102.     int         i;
  103.     int nmembers = children.length();
  104.  
  105.     for (i = 0 ; i < nmembers ; i++) {
  106.         Layoutable w = children.getChild(i);
  107.         if (w instanceof Component) {
  108.         ((Component)w).dispose();
  109.         }
  110.     }
  111.     super.dispose();
  112.     }
  113.  
  114.     /**
  115.      * Return the preferred size for this container.
  116.      */
  117.     public Dimension getPreferredSize() {
  118.     return (theLayout != null) ?
  119.         theLayout.getPreferredSize(this) :
  120.         super.getPreferredSize();
  121.     }
  122.  
  123.     /**
  124.      * Return the minimum acceptable size for this container.
  125.      */
  126.     public Dimension minDimension() {
  127.     return (theLayout != null) ?
  128.         theLayout.minDimension(this) : super.minDimension();
  129.     }
  130.  
  131.     /**
  132.      * Map the container and its members, note that
  133.      * super.Map() will layout the member object if
  134.      * needed.
  135.      */
  136.     public synchronized void map() {
  137.     int i;
  138.     int nmembers = children.length();
  139.     
  140.     if (mapped) {
  141.         return;
  142.     }
  143.  
  144.     super.map();
  145.  
  146.     for (i = 0 ; i < nmembers ; i++) {
  147.         Layoutable w = children.getChild(i);
  148.         if (w instanceof Component) {
  149.         ((Component)w).map();
  150.         }
  151.     }
  152.     }
  153.  
  154.     /**
  155.      * UnMap the container and its members.
  156.      */
  157.     public synchronized void unMap() {
  158.     int i;
  159.     int nmembers = children.length();
  160.     
  161.     if (!mapped) {
  162.         return;
  163.     }
  164.  
  165.     super.unMap();
  166.     for (i = 0 ; i < nmembers ; i++) {
  167.         Layoutable w = children.getChild(i);
  168.         if (w instanceof Component) {
  169.         ((Component)w).unMap();
  170.         }
  171.     }
  172.     }
  173.  
  174.     /**
  175.      * Change the layout of the container.
  176.      */
  177.     public synchronized void setLayout(ContainerLayout pLayout) {
  178.     theLayout = pLayout;
  179.     tidy = false;
  180.     }
  181.  
  182.     /**
  183.      * Move the container to the given position.
  184.      */
  185.     public void move(int pX, int pY) {
  186.     int    nchildren = children.length();
  187.     int    i;
  188.     int    dx = pX - x;
  189.     int    dy = pY - y;
  190.  
  191.     x = pX;
  192.     y = pY;
  193.  
  194.     for (i=0; i < nchildren; i++) {
  195.         Layoutable m = getChild(i);
  196.  
  197.         if (m instanceof Component) {
  198.         Component c = (Component)m;
  199.  
  200.         c.move(c.x + dx, c.y + dy);
  201.         }
  202.     }
  203.     }
  204.  
  205.     /**
  206.      * Layout the container and its members.
  207.      */
  208.     public synchronized void layout() {
  209.     int i;
  210.     int nmembers = children.length();
  211.  
  212.     if ((theLayout != null) && (!tidy)) {
  213.         theLayout.layout(this);
  214.     }
  215.     super.layout();
  216.     for (i = 0 ; i < nmembers ; i++) {
  217.         Layoutable w = children.getChild(i);
  218.         if (w instanceof Component) {
  219.         ((Component)w).layout();
  220.         }
  221.     }
  222.     }
  223.  
  224.     /**
  225.      * Set the insets of this container
  226.      */
  227.     public void setInsets(int n, int e, int s, int w) {
  228.     insets[ContainerLayout.NORTH] = n;
  229.     insets[ContainerLayout.EAST] = e;
  230.     insets[ContainerLayout.SOUTH] = s;
  231.     insets[ContainerLayout.WEST] = w;
  232.     }
  233.  
  234.     /**
  235.      * Change the insets of this container
  236.      */
  237.     public void addInsets(int n, int e, int s, int w) {
  238.     insets[ContainerLayout.NORTH] += n;
  239.     insets[ContainerLayout.EAST]  += e;
  240.     insets[ContainerLayout.SOUTH] += s;
  241.     insets[ContainerLayout.WEST]  += w;
  242.     tidy = false;
  243.     }
  244. }
  245.