Source for org.jfree.ui.OverlayLayout

   1: /* ========================================================================
   2:  * JCommon : a free general purpose class library for the Java(tm) platform
   3:  * ========================================================================
   4:  *
   5:  * (C) Copyright 2000-2005, by Object Refinery Limited and Contributors.
   6:  * 
   7:  * Project Info:  http://www.jfree.org/jcommon/index.html
   8:  *
   9:  * This library is free software; you can redistribute it and/or modify it 
  10:  * under the terms of the GNU Lesser General Public License as published by 
  11:  * the Free Software Foundation; either version 2.1 of the License, or 
  12:  * (at your option) any later version.
  13:  *
  14:  * This library is distributed in the hope that it will be useful, but 
  15:  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
  16:  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public 
  17:  * License for more details.
  18:  *
  19:  * You should have received a copy of the GNU Lesser General Public
  20:  * License along with this library; if not, write to the Free Software
  21:  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, 
  22:  * USA.  
  23:  *
  24:  * [Java is a trademark or registered trademark of Sun Microsystems, Inc. 
  25:  * in the United States and other countries.]
  26:  *
  27:  * ------------------------------
  28:  * OverlayLayout.java
  29:  * ------------------------------
  30:  * (C)opyright 2003, by Thomas Morgner and Contributors.
  31:  *
  32:  * Original Author:  Thomas Morgner;
  33:  * Contributor(s):   -;
  34:  *
  35:  * $Id: OverlayLayout.java,v 1.5 2005/10/18 13:18:34 mungady Exp $
  36:  *
  37:  * Changes
  38:  * -------------------------
  39:  * 09-12-2003 : Initial version
  40:  *
  41:  */
  42: package org.jfree.ui;
  43: 
  44: import java.awt.Component;
  45: import java.awt.Container;
  46: import java.awt.Dimension;
  47: import java.awt.Insets;
  48: import java.awt.LayoutManager;
  49: import java.awt.Rectangle;
  50: 
  51: /**
  52:  * A simple layoutmanager to overlay all components of a parent.
  53:  * <p/>
  54:  * This layout manager acts similiar to the card layout, but all
  55:  * childs of the parent band have the same size and all childs can
  56:  * be visible at the same time.
  57:  *
  58:  * @author Thomas Morgner
  59:  */
  60: public final class OverlayLayout implements LayoutManager {
  61: 
  62:     /**
  63:      * A flag that defines, whether invisible components should be ignored when
  64:      * computing the layout.
  65:      */
  66:     private boolean ignoreInvisible;
  67: 
  68:     /**
  69:      * Creates a new instance.
  70:      * 
  71:      * @param ignoreInvisible  whether to ignore invisible components when computing the layout.
  72:      */
  73:     public OverlayLayout(final boolean ignoreInvisible) {
  74:         this.ignoreInvisible = ignoreInvisible;
  75:     }
  76: 
  77:     /**
  78:      * DefaultConstructor.
  79:      */
  80:     public OverlayLayout() {
  81: 
  82:     }
  83: 
  84:     /**
  85:      * If the layout manager uses a per-component string,
  86:      * adds the component <code>comp</code> to the layout,
  87:      * associating it
  88:      * with the string specified by <code>name</code>.
  89:      *
  90:      * @param name the string to be associated with the component
  91:      * @param comp the component to be added
  92:      */
  93:     public void addLayoutComponent(final String name, final Component comp) {
  94:     }
  95: 
  96:     /**
  97:      * Removes the specified component from the layout.
  98:      *
  99:      * @param comp the component to be removed
 100:      */
 101:     public void removeLayoutComponent(final Component comp) {
 102:     }
 103: 
 104:     /**
 105:      * Lays out the specified container.
 106:      *
 107:      * @param parent the container to be laid out
 108:      */
 109:     public void layoutContainer(final Container parent) {
 110:         synchronized (parent.getTreeLock()) {
 111:             final Insets ins = parent.getInsets();
 112: 
 113:             final Rectangle bounds = parent.getBounds();
 114:             final int width = bounds.width - ins.left - ins.right;
 115:             final int height = bounds.height - ins.top - ins.bottom;
 116: 
 117:             final Component[] comps = parent.getComponents();
 118: 
 119:             for (int i = 0; i < comps.length; i++) {
 120:                 final Component c = comps[i];
 121:                 if ((comps[i].isVisible() == false) && this.ignoreInvisible) {
 122:                     continue;
 123:                 }
 124:                 c.setBounds(ins.left, ins.top, width, height);
 125:             }
 126:         }
 127:     }
 128: 
 129:     /**
 130:      * Calculates the minimum size dimensions for the specified
 131:      * container, given the components it contains.
 132:      *
 133:      * @param parent the component to be laid out
 134:      * @return the minimum size computed for the parent.
 135:      * @see #preferredLayoutSize
 136:      */
 137:     public Dimension minimumLayoutSize(final Container parent) {
 138:         synchronized (parent.getTreeLock()) {
 139:             final Insets ins = parent.getInsets();
 140:             final Component[] comps = parent.getComponents();
 141:             int height = 0;
 142:             int width = 0;
 143:             for (int i = 0; i < comps.length; i++) {
 144:                 if ((comps[i].isVisible() == false) && this.ignoreInvisible) {
 145:                     continue;
 146:                 }
 147: 
 148:                 final Dimension pref = comps[i].getMinimumSize();
 149:                 if (pref.height > height) {
 150:                     height = pref.height;
 151:                 }
 152:                 if (pref.width > width) {
 153:                     width = pref.width;
 154:                 }
 155:             }
 156:             return new Dimension(width + ins.left + ins.right,
 157:                 height + ins.top + ins.bottom);
 158:         }
 159:     }
 160: 
 161:     /**
 162:      * Calculates the preferred size dimensions for the specified
 163:      * container, given the components it contains.
 164:      *
 165:      * @param parent the container to be laid out
 166:      * @return the preferred size computed for the parent.
 167:      * @see #minimumLayoutSize
 168:      */
 169:     public Dimension preferredLayoutSize(final Container parent) {
 170:         synchronized (parent.getTreeLock()) {
 171:             final Insets ins = parent.getInsets();
 172:             final Component[] comps = parent.getComponents();
 173:             int height = 0;
 174:             int width = 0;
 175:             for (int i = 0; i < comps.length; i++) {
 176:                 if ((comps[i].isVisible() == false) && this.ignoreInvisible) {
 177:                     continue;
 178:                 }
 179: 
 180:                 final Dimension pref = comps[i].getPreferredSize();
 181:                 if (pref.height > height) {
 182:                     height = pref.height;
 183:                 }
 184:                 if (pref.width > width) {
 185:                     width = pref.width;
 186:                 }
 187:             }
 188:             return new Dimension(width + ins.left + ins.right,
 189:                 height + ins.top + ins.bottom);
 190:         }
 191:     }
 192: 
 193: }