/* $Id: LabelledLayout.java 19034 2011-02-13 18:12:44Z bobtarling $

  *****************************************************************************

  * Copyright (c) 2009 Contributors - see below

  * All rights reserved. This program and the accompanying materials

  * are made available under the terms of the Eclipse Public License v1.0

  * which accompanies this distribution, and is available at

  * http://www.eclipse.org/legal/epl-v10.html

  *

  * Contributors:

  *    bobtarling

  *****************************************************************************

  *

  * Some portions of this file was previously release using the BSD License:

  */

 // Copyright (c) 2008-2009 The Regents of the University of California. All

 // Rights Reserved. Permission to use, copy, modify, and distribute this

 // software and its documentation without fee, and without a written

 // agreement is hereby granted, provided that the above copyright notice

 // and this paragraph appear in all copies. This software program and

 // documentation are copyrighted by The Regents of the University of

 // California. The software program and documentation are supplied "AS

 // IS", without any accompanying services from The Regents. The Regents

 // does not warrant that the operation of the program will be

 // uninterrupted or error-free. The end-user understands that the program

 // was developed for research purposes and is advised not to rely

 // exclusively on the program for any reason. IN NO EVENT SHALL THE

 // UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,

 // SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS,

 // ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF

 // THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF

 // SUCH DAMAGE. THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY

 // WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE

 // PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF

 // CALIFORNIA HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT,

 // UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

 package org.argouml.uml.ui;

 import java.awt.Component;

 import java.awt.Container;

 import java.awt.Dimension;

 import java.awt.Insets;

 import java.awt.LayoutManager;

 import java.util.ArrayList;

 import javax.swing.JComboBox;

 import javax.swing.JLabel;

 import javax.swing.JPanel;

 import javax.swing.JToolBar;

 import javax.swing.UIManager;

 /**

  * This layout manager lines up components in 2 columns. All JLabels

  * are the first column and any component the JLabel is registered

  * with is in a second column next to the label. <p>

  *

  * Components are sized automatically to fill available space in the container

  * when it is resized. <p>

  * 

  * All JLabel widths will be the largest of the JLabel preferred widths (unless

  * the container is too narrow). <p>

  * 

  * The components will take up any left over width unless they are

  * restricted themselves by a maximum width. <p>

  * 

  * The height of each component is either fixed or will resize to use up any

  * available space in the container. Whether a components height is resizable

  * is determined by checking whether the preferred height of that component is

  * greater then its minimum height. This is the case for components such as

  * JList which would require to expand to show the maximum number or items. <p>

  * 

  * If a component is not to have its height resized then its preferred

  * height and minimum height should be the same. This is the case for

  * components such as JTextField and JComboBox* which should always stay the

  * same height. <p>

  * 

  * [There is known bug in JRE5 where the prefered height and minimum height of

  * a JComboBox can differ. LabelledLayout has coded a workaround for this bug.

  * See - http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6255154 ] <p>

  * 

  * LabelledLayout can show multiple panels of label/component

  * pairs. The seperation of these panels is indicated by adding a

  * Seperator component to the container. Labelled layout starts

  * a new panel when detecting this Seperator. <p>

  * 

  * When there are multiple panels, each panel is given equal width.

  * The width restriction of JLabels and components described above are then

  * dependent on panel width rather than container width.

  *

  * @author Bob Tarling

  */

 public class LabelledLayout implements LayoutManager, java.io.Serializable {

     private static final long serialVersionUID = -5596655602155151443L;

     /**

      * This is the horizontal gap (in pixels) which specifies the space

      * between sections.  They can be changed at any time.

      * This should be a non negative integer.

      *

      * @serial

      * @see #getHgap()

      * @see #setHgap(int)

      */

     private int hgap;

     /**

      * This is the vertical gap (in pixels) which specifies the space

      * between rows.  They can be changed at any time.

      * This should be a non negative integer.

      *

      * @serial

      * @see #getVgap()

      * @see #setVgap(int)

      */

     private int vgap;

     private boolean ignoreSplitters;

     /**

      * Construct a new LabelledLayout.

      */

     public LabelledLayout() {

         ignoreSplitters = false;

         hgap = 0;

         vgap = 0;

     }

     /**

      * Construct a new LabelledLayout.

      */

     public LabelledLayout(boolean ignoreSplitters) {

         this.ignoreSplitters = ignoreSplitters;

         this.hgap = 0;

         this.vgap = 0;

     }

     /**

      * Construct a new horizontal LabelledLayout with the specified

      * cell spacing.

      * @param hgap The horizontal gap between components

      * @param vgap The vertical gap between components

      */

     public LabelledLayout(int hgap, int vgap) {

         this.ignoreSplitters = false;

         this.hgap = hgap;

         this.vgap = vgap;

     }

     /** 

      * Adds the specified component with the specified name to the

      * layout. This is included to satisfy the LayoutManager interface

      * but is not actually used in this layout implementation.

      *

      * @param name the name of the component

      * @param comp the component to be added

      */

     public void addLayoutComponent(String name, Component comp) {

     }

     /** 

      * Removes the specified component from

      * the layout. This is included to satisfy the LayoutManager

      * interface but is not actually used in this layout

      * implementation.

      *

      * @param comp the component

      */

     public void removeLayoutComponent(Component comp) {

     }

     /**

      * Determines the preferred size of the container argument using

      * this labelled layout.  The preferred size is that all child

      * components are in one section at their own preferred size with

      * gaps and border indents.

      */

     public Dimension preferredLayoutSize(Container parent) {

         synchronized (parent.getTreeLock()) {

             final Insets insets = parent.getInsets();

             int preferredWidth = 0;

             int preferredHeight = 0;

             int widestLabel = 0;

             final int componentCount = parent.getComponentCount();

             for (int i = 0; i < componentCount; ++i) {

                 Component childComp = parent.getComponent(i);

                 if (childComp.isVisible()

                         && !(childComp instanceof Seperator)) {

                     int childHeight = getPreferredHeight(childComp);

                     if (childComp instanceof JLabel) {

                         final JLabel jlabel = (JLabel) childComp;

                         widestLabel = 

                             Math.max(widestLabel, getPreferredWidth(jlabel));

                         childComp = jlabel.getLabelFor();

                         final int childWidth = getPreferredWidth(childComp);

                         preferredWidth = 

                             Math.max(preferredWidth, childWidth);

                         childHeight =

                             Math.min(childHeight, getPreferredHeight(jlabel));

                     }

                     preferredHeight += childHeight + this.vgap;

                 }

             }

             preferredWidth += insets.left + widestLabel + insets.right;

             preferredHeight += insets.top + insets.bottom;

             return new Dimension(

                     insets.left + widestLabel + preferredWidth + insets.right,

                     preferredHeight);

         }

     }

     /** 

      * Required by LayoutManager.

      * 

      * @see java.awt.LayoutManager#minimumLayoutSize(java.awt.Container)

      */

     public Dimension minimumLayoutSize(Container parent) {

         synchronized (parent.getTreeLock()) {

             final Insets insets = parent.getInsets();

             int minimumHeight = insets.top + insets.bottom;

             final int componentCount = parent.getComponentCount();

             for (int i = 0; i < componentCount; ++i) {

                 Component childComp = parent.getComponent(i);

                 if (childComp instanceof JLabel) {

                     final JLabel jlabel = (JLabel) childComp;

                     childComp = jlabel.getLabelFor();

                     final int childHeight = Math.max(

                             getMinimumHeight(childComp),

                             getMinimumHeight(jlabel));

                     minimumHeight += childHeight + this.vgap;

                 }

             }

             return new Dimension(0, minimumHeight);

         }

     }

     /**

      * @see java.awt.LayoutManager#layoutContainer(java.awt.Container)

      */

     public void layoutContainer(Container parent) {

         synchronized (parent.getTreeLock()) {

             int sectionX = parent.getInsets().left;

             final ArrayList<Component> components = new ArrayList<Component>();

             final int sectionCount = getSectionCount(parent);

             final int sectionWidth = getSectionWidth(parent, sectionCount);

             int sectionNo = 0;

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

                 final Component childComp = parent.getComponent(i);

                 if (childComp instanceof Seperator) {

                     if (!this.ignoreSplitters) {

                         layoutSection(

                                 parent, 

                                 sectionX, 

                                 sectionWidth, 

                                 components, 

                                 sectionNo++);

                         sectionX += sectionWidth + this.hgap;

                         components.clear();

                     }

                 } else {

                     components.add(parent.getComponent(i));

                 }

             }

             layoutSection(

                     parent, 

                     sectionX, 

                     sectionWidth, 

                     components, 

                     sectionNo);

         }

     }

     /** Determine the number of sections.  There is only ever one

      * section if oriented vertically.  If oriented horizontally the

      * number of sections is deduced from the number of Splitters in

      * the parent container.

      */

     private int getSectionCount(Container parent) {

         int sectionCount = 1;

         final int componentCount = parent.getComponentCount();

         if (!ignoreSplitters) {

             for (int i = 0; i < componentCount; ++i) {

                 if (parent.getComponent(i) instanceof Seperator) {

                     ++sectionCount;

                 }

             }

         }

         return sectionCount;

     }

     /**

      * Determine the width of each section from the section count.

      * This is the working width minus the gaps between sections. This

      * result is then divided equally by the section count.

      */

     private int getSectionWidth(Container parent, int sectionCount) {

         return (getUsableWidth(parent) - (sectionCount - 1) * this.hgap)

                 / sectionCount;

     }

     /**

      * Determine the usable width of the parent.

      * This is the full width minus any borders.

      */

     private int getUsableWidth(Container parent) {

         final Insets insets = parent.getInsets();

         return parent.getWidth() - (insets.left + insets.right);

     }

     /**

      * Layout a single section

      */

     private void layoutSection(

             final Container parent,

             final int sectionX,

             final int sectionWidth,

             final ArrayList components,

             final int sectionNo) {

         final ArrayList<Integer> rowHeights = new ArrayList<Integer>();

         final int componentCount = components.size();

         if (componentCount == 0) {

             return;

         }

         int labelWidth = 0;

         int unknownHeightCount = 0;

         int totalHeight = 0;

         // Build up an array list of the heights of each label/component pair.

         // Heights of zero indicate a proportional height.

         Component previousComp = null;

         for (int i = 0; i < componentCount; ++i) {

             final Component childComp = (Component) components.get(i);

             final int childHeight;

             if (childComp instanceof JLabel) {

                 final JLabel jlabel = (JLabel) childComp;

                 final Component labelledComp = jlabel.getLabelFor();

                 labelWidth = Math.max(labelWidth, getPreferredWidth(jlabel));

                 if (labelledComp != null) {

                     ++i;

                     childHeight = getChildHeight(labelledComp);

                     if (childHeight == 0) {

                         ++unknownHeightCount;

                     }

                 } else {

                     childHeight = getPreferredHeight(jlabel);

                 }

                 totalHeight += childHeight + this.vgap;

                 rowHeights.add(new Integer(childHeight));

             } else {

                 // to manage the case there are no label/component

                 // pairs but just one component

                 childHeight = getChildHeight(childComp);

                 if (childHeight == 0) {

                     ++unknownHeightCount;

                 }

                 totalHeight += childHeight + this.vgap;

                 rowHeights.add(new Integer(childHeight));

             }

             previousComp = childComp;

         }

         totalHeight -= this.vgap;

         final Insets insets = parent.getInsets();

         final int parentHeight = 

             parent.getHeight() - (insets.top + insets.bottom);

         // Set the child components to the heights in the array list

         // calculating the height of any proportional component on the

         // fly.  FIXME - This assumes that the JLabel and the

         // component it labels have been added to the parent component

         // consecutively.

         int y = insets.top;

         int row = 0;

         previousComp = null;

         for (int i = 0; i < componentCount; ++i) {

             Component childComp = (Component) components.get(i);

             if (childComp.isVisible()) {

                 int rowHeight;

                 int componentWidth = sectionWidth;

                 int componentX = sectionX;

                 // If the component is a JLabel which has another

                 // component assigned then position/size the label and

                 // calculate the size of the registered component

                 if (childComp instanceof JLabel

                         && ((JLabel) childComp).getLabelFor() != null) {

                     i++; // Assumes the next child is the labelled component

                     final JLabel jlabel = (JLabel) childComp;

                     childComp = jlabel.getLabelFor();

                     jlabel.setBounds(sectionX, y, labelWidth,

                                      getPreferredHeight(jlabel));

                     componentWidth = sectionWidth - (labelWidth);

                     componentX = sectionX + labelWidth;

                 }

                 rowHeight = rowHeights.get(row).intValue();

                 if (rowHeight == 0) {

                     try {

                         rowHeight = calculateHeight(

                                 parentHeight, 

                                 totalHeight, 

                                 unknownHeightCount--, 

                                 childComp);

                     } catch (ArithmeticException e) {

                         String lookAndFeel = 

                             UIManager.getLookAndFeel().getClass().getName();

                         throw new IllegalStateException(

                                 "Division by zero laying out "

                                 + childComp.getClass().getName()

                                 + " on " + parent.getClass().getName()

                                 + " in section " + sectionNo

                                 + " using "

                                 + lookAndFeel,

                                 e);

                     }

                     totalHeight += rowHeight;

                 }

                 // Make sure the component width isn't any greater

                 // than its maximum allowed width

                 if (childComp.getMaximumSize() != null

                         && getMaximumWidth(childComp) < componentWidth) {

                     componentWidth = getMaximumWidth(childComp);

                 }

                 childComp.setBounds(componentX, y, componentWidth, rowHeight);

                 y += rowHeight + this.vgap;

                 ++row;

                 previousComp = childComp;

             }

         }

     }

     /**

      * @param childComp a component

      * @return 0 for a resizable component or a positive value for its fixed

      * height

      */

     private int getChildHeight(Component childComp) {

         if (isResizable(childComp)) {

             // If the child component is resizable then

             // we don't know it's actual size yet.

             // It will be calculated later as a

             // proportion of the available left over

             // space.  For now this is flagged as zero.

             return 0;

         } else {

             // If a preferred height is not given or is

             // the same as the minimum height then fix the

             // height of this row.

             return getMinimumHeight(childComp);

         }

     }

     /**

      * A component is resizable if its minimum size is less than

      * its preferred size.

      * There is a workaround here for a bug introduced in JRE5

      * where JComboBox minimum and preferred size now differ.

      * JComboBox is not resizable.

      * Anything in a JScrollPane is considered resizable

      * @param comp the component to check for resizability.

      * @return true if the given component should be resized to take u[p empty

      * space.

      */

     private boolean isResizable(Component comp) {

         if (comp == null) {

             return false;

         }

         if (comp instanceof JComboBox) {

             return false;

         }

         if (comp.getPreferredSize() == null) {

             return false;

         }

         if (comp.getMinimumSize() == null) {

             return false;

         }

         return (getMinimumHeight(comp) < getPreferredHeight(comp));

     }

     private final int calculateHeight(

             final int parentHeight, 

             final int totalHeight,

             final int unknownHeightsLeft, 

             final Component childComp) {

         return Math.max(

                 (parentHeight - totalHeight) / unknownHeightsLeft,

                 getMinimumHeight(childComp));

     }

     private int getPreferredHeight(final Component comp) {

         return (int) comp.getPreferredSize().getHeight();

     }

     private int getPreferredWidth(final Component comp) {

         return (int) comp.getPreferredSize().getWidth();

     }

     private int getMinimumHeight(final Component comp) {

         return (int) comp.getMinimumSize().getHeight();

     }

     private int getMaximumWidth(final Component comp) {

         return (int) comp.getMaximumSize().getWidth();

     }

     /**

      * Create a new instance of the Separator that splits the layout in columns

      * @return the separator

      */

     public static Seperator getSeparator() {

         return new Seperator();

     }

     /**

      * @return the horizontal gaps between components

      */

     public int getHgap() {

         return this.hgap;

     }

     /**

      * Set the horizontal gaps between components

      * @param hgap the horizontal gap

      */

     public void setHgap(int hgap) {

         this.hgap = hgap;

     }

     /**

      * @return the vertical gaps between components

      */

     public int getVgap() {

         return this.vgap;

     }

     /**

      * Set the vertical gaps between components

      * @param vgap the horizontal gap

      */

     public void setVgap(int vgap) {

         this.vgap = vgap;

     }

 }

 class Seperator extends JPanel {

     private static final long serialVersionUID = -4143634500959911688L;

     Seperator() {

         super.setVisible(false);

     }

 }