com.alee.extended.layout.SingleFiledLayout Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of weblaf-ui Show documentation
Show all versions of weblaf-ui Show documentation
WebLaf is a Java Swing Look and Feel and extended components library for cross-platform applications
/*
* This file is part of WebLookAndFeel library.
*
* WebLookAndFeel library is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* WebLookAndFeel library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with WebLookAndFeel library. If not, see .
*/
/*
* ====================================================================
*
* The Clearthought Software License, Version 1.0
*
* Copyright (c) 2001 Daniel Barbalace. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. The original software may not be altered. However, the classes
* provided may be subclasses as long as the subclasses are not
* packaged in the info.clearthought package or any subpackage of
* info.clearthought.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR, AFFILATED BUSINESSES,
* OR ANYONE ELSE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*/
package com.alee.extended.layout;
import java.awt.*;
import java.io.Serializable;
/**
* SingleFiledLayout lays out components singled filed. This layout manager is like FlowLayout
* except that all components are placed in a single row or column.
*
* @author Daniel E. Barbalace
* @version 1.1 April 4, 2002
*/
@SuppressWarnings ( { "ALL" } )
public class SingleFiledLayout implements LayoutManager, Serializable
{
/**
* Align components in a column
*/
public static final int COLUMN = 0;
/**
* Align components in a row
*/
public static final int ROW = 1;
/**
* Left justify components
*/
public static final int LEFT = 0;
/**
* Top justify components
*/
public static final int TOP = 0;
/**
* Center components
*/
public static final int CENTER = 1;
/**
* Full justify components
*/
public static final int FULL = 2;
/**
* Bottom justify components
*/
public static final int BOTTOM = 3;
/**
* Right justify components
*/
public static final int RIGHT = 4;
/**
* Default gap -- derived classes may override
*/
public static int DEFAULT_GAP = 5;
/**
* ROW or COLUMN -- should the components be aligned in a row or column
*/
protected int orientation;
/**
* LEFT, TOP, CENTER, FULL, BOTTOM, RIGHT -- how should components of different sizes be
* aligned
*/
protected int justification;
/**
* Space between components in pixels
*/
protected int gap;
/**
* Constructs an instance of SingleFiledLayout that will align components in a column using the
* default gap and LEFT justification.
*/
public SingleFiledLayout ()
{
this ( COLUMN, LEFT, DEFAULT_GAP );
}
/**
* Constructs an instance of SingleFiledLayout using the default gap and LEFT or TOP
* justification.
*
* @param orientation ROW or COLUMN -- should the components be aligned in a row or column
*/
public SingleFiledLayout ( int orientation )
{
this ( orientation, LEFT, DEFAULT_GAP );
}
/**
* Constructs an instance of SingleFiledLayout.
*
* @param orientation ROW or COLUMN -- should the components be aligned in a row or column
* @param justification LEFT, TOP, CENTER, FULL, BOTTOM, RIGHT -- how should components of
* different sizes be aligned
* @param gap space between components in pixels
*/
public SingleFiledLayout ( int orientation, int justification, int gap )
{
// Validate parameters
if ( orientation != ROW )
{
orientation = COLUMN;
}
if ( ( justification != CENTER ) && ( justification != FULL ) &&
( justification != RIGHT ) )
{
justification = LEFT;
}
if ( gap < 0 )
{
gap = 0;
}
// Copy parameters
this.orientation = orientation;
this.justification = justification;
this.gap = gap;
}
/**
* To lay out the specified container using this layout. This method repositions the components
* in the specified target container. User code should not have to call this method
* directly.
*
* @param container container being served by this layout manager
*/
public void layoutContainer ( Container container )
{
// Use preferred size to get maximum width or height
Dimension size = container.getSize ();
// Get the container's insets
Insets inset = container.getInsets ();
// Start at top left of container
int x = inset.left;
int y = inset.top;
// Get the components inside the container
Component component[] = container.getComponents ();
// Components arranged in a column
if ( orientation == COLUMN )
// Add each component
{
for ( int counter = 0; counter < component.length; counter++ )
{
// Use preferred size of component
Dimension d = component[ counter ].getPreferredSize ();
// Align component
switch ( justification )
{
case LEFT:
x = inset.left;
break;
case CENTER:
x = ( ( size.width - d.width ) >> 1 ) + inset.left - inset.right;
break;
case FULL:
x = inset.left;
d.width = size.width - inset.left - inset.right;
break;
case RIGHT:
x = size.width - d.width - inset.right;
break;
}
// Set size and location
component[ counter ].setBounds ( x, y, d.width, d.height );
// Increment y
y += d.height + gap;
}
}
// Components arranged in a row
else
// Add each component
{
for ( int counter = 0; counter < component.length; counter++ )
{
// Use preferred size of component
Dimension d = component[ counter ].getPreferredSize ();
// Align component
switch ( justification )
{
case TOP:
y = inset.top;
break;
case CENTER:
y = ( ( size.height - d.height ) >> 1 ) + inset.top - inset.bottom;
break;
case FULL:
y = inset.top;
d.height = size.height - inset.top - inset.bottom;
break;
case BOTTOM:
y = size.height - d.height - inset.bottom;
break;
}
// Set size and location
component[ counter ].setBounds ( x, y, d.width, d.height );
// Increment x
x += d.width + gap;
}
}
}
/**
* Determines the preferred size of the container argument using this layout. The preferred size
* is the smallest size that, if used for the container's size, will ensure that no component is
* truncated when the component is it's preferred size.
*
* @param container container being served by this layout manager
* @return a dimension indicating the container's preferred size
*/
public Dimension preferredLayoutSize ( Container container )
{
int totalWidth = 0; // Width of all components
int totalHeight = 0; // Height of all components
// Get the components inside the container
Component component[] = container.getComponents ();
// Components arranged in a column
if ( orientation == COLUMN )
{
// Add each component
for ( int counter = 0; counter < component.length; counter++ )
{
Dimension d = component[ counter ].getPreferredSize ();
if ( totalWidth < d.width )
{
totalWidth = d.width;
}
totalHeight += d.height + gap;
}
// Subtract extra gap
totalHeight -= gap;
}
// Components arranged in a row
else
{
// Add each component
for ( int counter = 0; counter < component.length; counter++ )
{
Dimension d = component[ counter ].getPreferredSize ();
totalWidth += d.width + gap;
if ( totalHeight < d.height )
{
totalHeight = d.height;
}
}
// Subtract extra gap
totalWidth -= gap;
}
// Add insets to preferred size
Insets inset = container.getInsets ();
totalWidth += inset.left + inset.right;
totalHeight += inset.top + inset.bottom;
return new Dimension ( totalWidth, totalHeight );
}
/**
* Determines the minimum size of the container argument using this layout. The minimum size is
* the smallest size that, if used for the container's size, will ensure that no component is
* truncated. The minimum size is the preferred size.
*
* @param container container being served by this layout manager
* @return a dimension indicating the container's minimum size
*/
public Dimension minimumLayoutSize ( Container container )
{
int totalWidth = 0; // Width of all components
int totalHeight = 0; // Height of all components
// Get the components inside the container
Component component[] = container.getComponents ();
// Components arranged in a column
if ( orientation == COLUMN )
{
// Add each component
for ( int counter = 0; counter < component.length; counter++ )
{
Dimension d = component[ counter ].getMinimumSize ();
if ( totalWidth < d.width )
{
totalWidth = d.width;
}
totalHeight += d.height + gap;
}
// Subtract extra gap
totalHeight -= gap;
}
// Components arranged in a row
else
{
// Add each component
for ( int counter = 0; counter < component.length; counter++ )
{
Dimension d = component[ counter ].getMinimumSize ();
totalWidth += d.width + gap;
if ( totalHeight < d.height )
{
totalHeight = d.height;
}
}
// Subtract extra gap
totalWidth = -gap;
}
// Add insets to preferred size
Insets inset = container.getInsets ();
totalWidth += inset.left + inset.right;
totalHeight += inset.top + inset.bottom;
return new Dimension ( totalWidth, totalHeight );
}
/**
* Adds the specified component with the specified name to the layout.
*
* @param name dummy parameter
* @param component component to add
*/
public void addLayoutComponent ( String name, Component component )
{
//
}
/**
* Removes the specified component with the specified name from the layout.
*
* @param component component being removed
*/
public void removeLayoutComponent ( Component component )
{
//
}
}