import java.awt.*;

import javax.swing.*;

/**

* A panel that implements the Scrollable interface. This class allows you

* to customize the scrollable features by using newly provided setter methods

* so you don't have to extend this class every time.

*

* Scrollable amounts can be specifed as a percentage of the viewport size or

* as an actual pixel value. The amount can be changed for both unit and block

* scrolling for both horizontal and vertical scrollbars.

*

* The Scrollable interface only provides a boolean value for determining whether

* or not the viewport size (width or height) should be used by the scrollpane

* when determining if scrollbars should be made visible. This class supports the

* concept of dynamically changing this value based on the size of the viewport.

* In this case the viewport size will only be used when it is larger than the

* panels size. This has the effect of ensuring the viewport is always full as

* components added to the panel will be size to fill the area available,

* based on the rules of the applicable layout manager of course.

*/

public class ScrollablePanel extends JPanel

implements Scrollable, SwingConstants

{

public enum ScrollableSizeHint

{

NONE,

FIT,

STRETCH;

}

public enum IncrementType

{

PERCENT,

PIXELS;

}

private ScrollableSizeHint scrollableHeight = ScrollableSizeHint.NONE;

private ScrollableSizeHint scrollableWidth = ScrollableSizeHint.NONE;

private IncrementInfo horizontalBlock;

private IncrementInfo horizontalUnit;

private IncrementInfo verticalBlock;

private IncrementInfo verticalUnit;

/**

* Default constructor that uses a FlowLayout

*/

public ScrollablePanel()

{

this( new FlowLayout() );

}

/**

* Constuctor for specifying the LayoutManager of the panel.

*

* @param layout the LayountManger for the panel

*/

public ScrollablePanel(LayoutManager layout)

{

super( layout );

IncrementInfo block = new IncrementInfo(IncrementType.PERCENT, 100);

IncrementInfo unit = new IncrementInfo(IncrementType.PERCENT, 10);

setScrollableBlockIncrement(HORIZONTAL, block);

setScrollableBlockIncrement(VERTICAL, block);

setScrollableUnitIncrement(HORIZONTAL, unit);

setScrollableUnitIncrement(VERTICAL, unit);

}

/**

* Get the height ScrollableSizeHint enum

*

* @return the ScrollableSizeHint enum for the height

*/

public ScrollableSizeHint getScrollableHeight()

{

return scrollableHeight;

}

/**

* Set the ScrollableSizeHint enum for the height. The enum is used to

* determine the boolean value that is returned by the

* getScrollableTracksViewportHeight() method. The valid values are:

*

* ScrollableSizeHint.NONE - return "false", which causes the height

* of the panel to be used when laying out the children

* ScrollableSizeHint.FIT - return "true", which causes the height of

* the viewport to be used when laying out the children

* ScrollableSizeHint.STRETCH - return "true" when the viewport height

* is greater than the height of the panel, "false" otherwise.

*

* @param scrollableHeight as represented by the ScrollableSizeHint enum.

*/

public void setScrollableHeight(ScrollableSizeHint scrollableHeight)

{

this.scrollableHeight = scrollableHeight;

revalidate();

}

/**

* Get the width ScrollableSizeHint enum

*

* @return the ScrollableSizeHint enum for the width

*/

public ScrollableSizeHint getScrollableWidth()

{

return scrollableWidth;

}

/**

* Set the ScrollableSizeHint enum for the width. The enum is used to

* determine the boolean value that is returned by the

* getScrollableTracksViewportWidth() method. The valid values are:

*

* ScrollableSizeHint.NONE - return "false", which causes the width

* of the panel to be used when laying out the children

* ScrollableSizeHint.FIT - return "true", which causes the width of

* the viewport to be used when laying out the children

* ScrollableSizeHint.STRETCH - return "true" when the viewport width

* is greater than the width of the panel, "false" otherwise.

*

* @param scrollableWidth as represented by the ScrollableSizeHint enum.

*/

public void setScrollableWidth(ScrollableSizeHint scrollableWidth)

{

this.scrollableWidth = scrollableWidth;

revalidate();

}

/**

* Get the block IncrementInfo for the specified orientation

*

* @return the block IncrementInfo for the specified orientation

*/

public IncrementInfo getScrollableBlockIncrement(int orientation)

{

return orientation == SwingConstants.HORIZONTAL ? horizontalBlock : verticalBlock;

}

/**

* Specify the information needed to do block scrolling.

*

* @param orientation specify the scrolling orientation. Must be either:

* SwingContants.HORIZONTAL or SwingContants.VERTICAL.

* @paran type specify how the amount parameter in the calculation of

* the scrollable amount. Valid values are:

* IncrementType.PERCENT - treat the amount as a % of the viewport size

* IncrementType.PIXEL - treat the amount as the scrollable amount

* @param amount a value used with the IncrementType to determine the

* scrollable amount

*/

public void setScrollableBlockIncrement(int orientation, IncrementType type, int amount)

{

IncrementInfo info = new IncrementInfo(type, amount);

setScrollableBlockIncrement(orientation, info);

}

/**

* Specify the information needed to do block scrolling.

*

* @param orientation specify the scrolling orientation. Must be either:

* SwingContants.HORIZONTAL or SwingContants.VERTICAL.

* @param info An IncrementInfo object containing information of how to

* calculate the scrollable amount.

*/

public void setScrollableBlockIncrement(int orientation, IncrementInfo info)

{

switch(orientation)

{

case SwingConstants.HORIZONTAL:

horizontalBlock = info;

break;

case SwingConstants.VERTICAL:

verticalBlock = info;

break;

default:

throw new IllegalArgumentException("Invalid orientation: " + orientation);

}

}

/**

* Get the unit IncrementInfo for the specified orientation

*

* @return the unit IncrementInfo for the specified orientation

*/

public IncrementInfo getScrollableUnitIncrement(int orientation)

{

return orientation == SwingConstants.HORIZONTAL ? horizontalUnit : verticalUnit;

}

/**

* Specify the information needed to do unit scrolling.

*

* @param orientation specify the scrolling orientation. Must be either:

* SwingContants.HORIZONTAL or SwingContants.VERTICAL.

* @paran type specify how the amount parameter in the calculation of

* the scrollable amount. Valid values are:

* IncrementType.PERCENT - treat the amount as a % of the viewport size

* IncrementType.PIXEL - treat the amount as the scrollable amount

* @param amount a value used with the IncrementType to determine the

* scrollable amount

*/

public void setScrollableUnitIncrement(int orientation, IncrementType type, int amount)

{

IncrementInfo info = new IncrementInfo(type, amount);

setScrollableUnitIncrement(orientation, info);

}

/**

* Specify the information needed to do unit scrolling.

*

* @param orientation specify the scrolling orientation. Must be either:

* SwingContants.HORIZONTAL or SwingContants.VERTICAL.

* @param info An IncrementInfo object containing information of how to

* calculate the scrollable amount.

*/

public void setScrollableUnitIncrement(int orientation, IncrementInfo info)

{

switch(orientation)

{

case SwingConstants.HORIZONTAL:

horizontalUnit = info;

break;

case SwingConstants.VERTICAL:

verticalUnit = info;

break;

default:

throw new IllegalArgumentException("Invalid orientation: " + orientation);

}

}

// Implement Scrollable interface

public Dimension getPreferredScrollableViewportSize()

{

return getPreferredSize();

}

public int getScrollableUnitIncrement(

Rectangle visible, int orientation, int direction)

{

switch(orientation)

{

case SwingConstants.HORIZONTAL:

return getScrollableIncrement(horizontalUnit, visible.width);

case SwingConstants.VERTICAL:

return getScrollableIncrement(verticalUnit, visible.height);

default:

throw new IllegalArgumentException("Invalid orientation: " + orientation);

}

}

public int getScrollableBlockIncrement(

Rectangle visible, int orientation, int direction)

{

switch(orientation)

{

case SwingConstants.HORIZONTAL:

return getScrollableIncrement(horizontalBlock, visible.width);

case SwingConstants.VERTICAL:

return getScrollableIncrement(verticalBlock, visible.height);

default:

throw new IllegalArgumentException("Invalid orientation: " + orientation);

}

}

protected int getScrollableIncrement(IncrementInfo info, int distance)

{

if (info.getIncrement() == IncrementType.PIXELS)

return info.getAmount();

else

return distance * info.getAmount() / 100;

}

public boolean getScrollableTracksViewportWidth()

{

if (scrollableWidth == ScrollableSizeHint.NONE)

return false;

if (scrollableWidth == ScrollableSizeHint.FIT)

return true;

// STRETCH sizing, use the greater of the panel or viewport width

if (getParent() instanceof JViewport)

{

return (((JViewport)getParent()).getWidth() > getPreferredSize().width);

}

return false;

}

public boolean getScrollableTracksViewportHeight()

{

if (scrollableHeight == ScrollableSizeHint.NONE)

return false;

if (scrollableHeight == ScrollableSizeHint.FIT)

return true;

// STRETCH sizing, use the greater of the panel or viewport height

if (getParent() instanceof JViewport)

{

return (((JViewport)getParent()).getHeight() > getPreferredSize().height);

}

return false;

}

/**

* Helper class to hold the information required to calculate the scroll amount.

*/

static class IncrementInfo

{

private IncrementType type;

private int amount;

public IncrementInfo(IncrementType type, int amount)

{

this.type = type;

this.amount = amount;

}

public IncrementType getIncrement()

{

return type;

}

public int getAmount()

{

return amount;

}

public String toString()

{

return

"ScrollablePanel[" +

type + ", " +

amount + "]";

}

}

}