All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.alee.extended.layout.SingleFiledLayout Maven / Gradle / Ivy

Go to download

WebLaf is a Java Swing Look and Feel and extended components library for cross-platform applications

There is a newer version: 2.2.1
Show newest version
/*
 * 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 ) { // } }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy