/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of CosyBeans-Common.
    *
    * CosyBeans-Common 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.
   *
   * CosyBeans-Common 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 CosyBeans-Common.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.gui.components;
  
  import com.cosylab.gui.components.util.Actions;
  import com.cosylab.gui.components.util.ColorHelper;
  import com.cosylab.gui.components.util.CosyUIElements;
  
  import java.awt.Color;
  import java.awt.Component;
  import java.awt.Container;
  import java.awt.Dimension;
  import java.awt.Font;
  import java.awt.Graphics;
  import java.awt.Insets;
  import java.awt.LayoutManager;
  import java.awt.event.ComponentAdapter;
  import java.awt.event.ComponentEvent;
  import java.awt.event.FocusAdapter;
  import java.awt.event.FocusEvent;
  import java.awt.event.KeyAdapter;
  import java.awt.event.KeyEvent;
  import java.awt.event.MouseAdapter;
  import java.awt.event.MouseEvent;
  
  import java.beans.PropertyChangeEvent;
  import java.beans.PropertyChangeListener;
  
  import java.util.ArrayList;
  import java.util.Iterator;
  
  import javax.swing.AbstractButton;
  import javax.swing.Action;
  import javax.swing.Icon;
  import javax.swing.JButton;
  import javax.swing.JPanel;
  import javax.swing.JToggleButton;
  import javax.swing.border.Border;
  import javax.swing.event.ChangeEvent;
  import javax.swing.event.ChangeListener;
  
  
  /**
   * This is a <code>JComponent</code>, which is a combination of a label and a
   * toolbar. It contains an <code>Icon</code> read-write property called
   * <code>icon</code>,  which sets the icon to be displayed in the left part of
   * the title bar. The <code>String</code> read-write property
   * <code>title</code>, which is the text written to the right of the icon, and
   * a set of <code>JButton</code> objects displayed on the right side of the
   * title bar or below the label. <br>
   * The default color of the title bar is retrieved from the {@link
   * com.cosylab.gui.components.util.ColorHelper} class and can change with
   * different virtual machines and L&Fs. Two different colors are used: focus
   * color for the left start of the background gradient and textHighlight color
   * for the right part. When the PanelTitleBar is not in active state, the
   * whole bar is painted with the background color. The changes of state can be
   * achieved by calling the <code>setActive() </code> method.
   *
   * @author <a href="mailto:miha.kadunc@cosylab.com">Miha Kadunc</a>
   * @version $id$
   *
   * @see com.cosylab.gui.components.TitledPanel
   */
  public class PanelTitleBar extends JPanel
  {
  	private static final long serialVersionUID = 1L;
  
  	/** DOCUMENT ME! */
  	public static final String ACTION_STICKY = "sticky";
  
  	/** DOCUMENT ME! */
  	public static final String ACTION_VISIBLE = "visible";
  	private Border pressedBorder = CosyUIElements.getPlainBorder(false);
  	private Border overBorder = CosyUIElements.getPlainBorder(true);
  	private static final String BUTTON_KEY = "com.cosylab.gui.components.PanelTitleBar Key For Buttons 2431";
  	private GradientLabel title = null;
  	private ArrayList<AbstractButton> buttons = null;
  	private int selectedIndex = -1;
  	private boolean mouseIn = false;
  	private PanelTitleBarLayout titleBarLayout;
  
  	private class PanelTitleBarLayout implements LayoutManager
 	{
 		private int height = 38;
 		private PanelTitleBar panel = null;
 		private int panelWidth = 0;
 		private int minWidth = 0;
 		private int minHeight = 0;
 
 		/**
 		 * Creates a new PanelTitleBarLayout object.
 		 *
 		 * @param height DOCUMENT ME!
 		 */
 		public PanelTitleBarLayout(int height)
 		{
 			setHeight(height);
 		}
 
 		/**
 		 * @see LayoutManager#addLayoutComponent(String, Component)
 		 */
 		public void addLayoutComponent(String name, Component comp)
 		{
 			reposition(true);
 		}
 
 		/**
 		 * @see LayoutManager#removeLayoutComponent(Component)
 		 */
 		public void removeLayoutComponent(Component comp)
 		{
 			if ((panel != null) && (panel.getButtonsList() != null)) {
 				if (panel.getButtonsList().contains(comp)) {
 					panel.getButtonsList().remove(comp);
 				}
 
 				reposition(true);
 			}
 		}
 
 		/**
 		 * @see LayoutManager#preferredLayoutSize(Container)
 		 */
 		public Dimension preferredLayoutSize(Container parent)
 		{
 			reposition(true);
 
 			if (panel == null) {
 				return new Dimension(height, height);
 			}
 
 			return new Dimension(panel.getTitleLabel().getPreferredSize().width
 			    + panel.getButtonsList().size() * height
 			    + panel.getInsets().left + panel.getInsets().right, minHeight);
 		}
 
 		/**
 		 * @see LayoutManager#minimumLayoutSize(Container)
 		 */
 		public Dimension minimumLayoutSize(Container parent)
 		{
 			reposition(true);
 
 			return new Dimension(minWidth, minHeight);
 		}
 
 		/**
 		 * @see LayoutManager#layoutContainer(Container)
 		 */
 		public void layoutContainer(Container parent)
 		{
 			if (panel == null) {
 				panel = (PanelTitleBar)parent;
 				panel.addComponentListener(new ComponentAdapter() {
 						public void componentResized(ComponentEvent event)
 						{
 							int h = minHeight;
 							reposition(false);
 
 							if (h != minHeight) {
 								panelWidth = -1;
 								panel.revalidate();
 							}
 						}
 					});
 				reposition(true);
 			}
 		}
 
 		private void reposition(boolean force)
 		{
 			if ((panel == null) || (panel.getTitleLabel() == null)) {
 				return;
 			}
 
 			if ((force) || (panel.getWidth() != panelWidth)) {
 				panelWidth = panel.getWidth();
 
 				int titleWidth = panel.getTitleLabel().getPreferredSize().width;
 				int numButtons = 0;
 
 				for (Iterator iterator = panel.getButtonsList().iterator();
 				    iterator.hasNext();) {
 					AbstractButton b = (AbstractButton)iterator.next();
 
 					if (!isVisible(b)) {
 						continue;
 					}
 
 					if (!isSticky(b)) {
 						numButtons++;
 					}
 				}
 
 				int[] currX = new int[]{ 0, 0 };
 				int[] currY = new int[]{ 1, 1 };
 				int botIdx = 0;
 
 				if (((panelWidth - titleWidth - numButtons * height) < 0)
 				    && (numButtons != 0)) {
 					currY[1] = height - 1;
 					botIdx = 1;
 				}
 
 				currX[0] = panelWidth - height + 1;
 				currX[1] = currX[0];
 
 				for (Iterator iterator = panel.getButtonsList().iterator();
 				    iterator.hasNext();) {
 					AbstractButton b = (AbstractButton)iterator.next();
 
 					if (!isVisible(b)) {
 						b.setVisible(false);
 					} else {
 						b.setVisible(true);
 
 						if (isSticky(b)) {
 							b.setBounds(currX[0], currY[0], height - 2,
 							    height - 2);
 							currX[0] = currX[0] - height + 2;
 						} else {
 							b.setBounds(currX[botIdx], currY[botIdx],
 							    height - 2, height - 2);
 							currX[botIdx] = currX[botIdx] - height + 2;
 						}
 					}
 				}
 
 				titleWidth = currX[0] + height - 3;
 				panel.getTitleLabel().setBounds(1, 1, titleWidth, height - 2);
 				minHeight = currY[botIdx] + height - 1;
 				panel.setMinimumSize(new Dimension(height, minHeight));
 			}
 		}
 
 		private boolean isSticky(AbstractButton b)
 		{
 			if (b.getAction() == null) {
 				return false;
 			}
 
 			Action act = b.getAction();
 
 			return act.getValue(ACTION_STICKY) == Boolean.TRUE;
 		}
 
 		private boolean isVisible(AbstractButton b)
 		{
 			if (b.getAction() == null) {
 				return b.isVisible();
 			}
 
 			Action act = b.getAction();
 
 			return act.getValue(ACTION_VISIBLE) != Boolean.FALSE;
 		}
 
 		int getHeight()
 		{
 			return height;
 		}
 
 		void setHeight(int height)
 		{
 			this.height = height;
 			reposition(true);
 		}
 	}
 
 	/**
 	 * Constructs a <code>PanelTitleBar</code> with a defined height, a title
 	 * and an icon.
 	 *
 	 * @param title The <code>String</code> that labels the title bar.
 	 * @param icon The <code>Icon</code> which will be displayed in the left.
 	 * @param height Height of the title bar and size of the buttons.
 	 */
 	public PanelTitleBar(String title, Icon icon, int height)
 	{
 		super();
 		this.title = new GradientLabel(title);
 
 		if (icon != null) {
 			this.title.setIcon(icon);
 		}
 
 		buttons = new ArrayList<AbstractButton>(10);
 		initialize(height);
 	}
 
 	/**
 	 * Constructs a <code>PanelTitleBar</code> with a title. The height is set
 	 * to 24 points and there is no icon shown.
 	 *
 	 * @param title The <code>String</code> that labels the title bar.
 	 */
 	public PanelTitleBar(String title)
 	{
 		this(title, null, 24);
 	}
 
 	/**
 	 * Constructs a default empty <code>PanelTitleBar</code>.  The title bar is
 	 * 24 points high, has no title or icon and contains no buttons.
 	 */
 	public PanelTitleBar()
 	{
 		this("");
 	}
 
 	/**
 	 * Gets the <code>title</code> property.
 	 *
 	 * @return Returns the <code>String</code> that labels this title bar.
 	 */
 	public String getTitle()
 	{
 		return title.getText();
 	}
 
 	/**
 	 * Sets the title property, which is displayed in the top-left area of this
 	 * title bar.
 	 *
 	 * @param title The text to be shown as the title.
 	 */
 	public void setTitle(String title)
 	{
 		this.title.setText(title);
 	}
 
 	private void setSelectedButton(AbstractButton button)
 	{
 		if ((selectedIndex > -1) && (selectedIndex < buttons.size())) {
 			AbstractButton old = buttons.get(selectedIndex);
 			old.setBorderPainted(old.isSelected());
 			old.setOpaque(false);
 		}
 
 		if (button != null) {
 			button.setBorderPainted(true);
 			button.setOpaque(true);
 			selectedIndex = buttons.indexOf(button);
 		} else {
 			selectedIndex = -1;
 		}
 	}
 
 	/**
 	 * Gets the <code>icon</code> property.
 	 *
 	 * @return Returns the <code>Icon</code> that is displayed by this title
 	 *         bar.
 	 */
 	public Icon getIcon()
 	{
 		return title.getIcon();
 	}
 
 	/**
 	 * Sets the <code>icon</code> property. The <code>Icon</code> passed as the
 	 * parameter to this method is displayed in the top left corner of this
 	 * panel.
 	 *
 	 * @param icon the icon to be set.
 	 *
 	 * @see #setIcon(Icon)
 	 */
 	public void setIcon(Icon icon)
 	{
 		title.setIcon(icon);
 	}
 
 	/**
 	 * Adds an <code>AbstractButton</code> to this title bar. Note that all the
 	 * user has to provide is the button's icon and an associated action. All
 	 * the behaviour needed for the button to fit into the title bar will be
 	 * added to the button by the <code>PanelTitleBar</code>.  The button will
 	 * be resized to a square with the same size as the  height of the bar.
 	 * Its background color will be changed  to that of the bar and the border
 	 * will be removed.  Some mouse and keyboard sensitivity will be added to
 	 * the button.
 	 *
 	 * @param index DOCUMENT ME!
 	 * @param button The button to be added to the title bar.
 	 *
 	 * @see #removeButton(AbstractButton)
 	 */
 	public void addButton(int index, AbstractButton button)
 	{
 		final AbstractButton butt = button;
 		buttons.add(index, butt);
 
 		if (butt.isSelected()) {
 			butt.setBorder(pressedBorder);
 		} else {
 			butt.setBorder(overBorder);
 		}
 
 		butt.setFocusable(false);
 		butt.setBorderPainted(butt.isSelected());
 		butt.setOpaque(false);
 		butt.setBackground(getBackground());
 		butt.addMouseListener(new MouseAdapter() {
 				public void mouseEntered(MouseEvent event)
 				{
 					if (butt.isEnabled()) {
 						setSelectedButton(butt);
 					}
 
 					mouseIn = true;
 				}
 
 				public void mouseExited(MouseEvent event)
 				{
 					setSelectedButton(null);
 					mouseIn = false;
 				}
 
 				/**
 				 * @see java.awt.event.MouseAdapter#mousePressed(MouseEvent)
 				 */
 				public void mousePressed(MouseEvent e)
 				{
 					if (butt.isEnabled()) {
 						butt.setBorder(pressedBorder);
 
 						if (pressedBorder != null) {
 							butt.setBorderPainted(true);
 						} else {
 							butt.setBorderPainted(false);
 						}
 					}
 				}
 
 				/**
 				 * @see java.awt.event.MouseAdapter#mouseReleased(MouseEvent)
 				 */
 				public void mouseReleased(MouseEvent e)
 				{
 					if (butt.isSelected()) {
 						butt.setBorder(pressedBorder);
 
 						if (pressedBorder != null) {
 							butt.setBorderPainted(true);
 						} else {
 							butt.setBorderPainted(false);
 						}
 					} else {
 						butt.setBorder(overBorder);
 
 						if (overBorder != null) {
 							if (butt.isEnabled()) {
 								butt.setBorderPainted(true);
 							}
 						} else {
 							butt.setBorderPainted(false);
 						}
 					}
 				}
 			});
 
 		if (butt instanceof JToggleButton) {
 			butt.addChangeListener(new ChangeListener() {
 					/**
 					 * @see com.cosylab.introspection.PropertyChangeAdapter#propertyChange(PropertyChangeEvent)
 					 */
 					public void stateChanged(ChangeEvent evt)
 					{
 						if (butt.isSelected()) {
 							butt.setBorder(pressedBorder);
 
 							if (pressedBorder != null) {
 								butt.setBorderPainted(true);
 							} else {
 								butt.setBorderPainted(false);
 							}
 						} else {
 							butt.setBorder(overBorder);
 
 							if (overBorder != null) {
 								butt.setBorderPainted(true);
 							} else {
 								butt.setBorderPainted(false);
 							}
 						}
 					}
 				});
 		}
 
 		add(butt, "Button");
 	}
 
 	/**
 	 * Adds a button to this component.
 	 *
 	 * @param button
 	 *
 	 * @see #addActionButton(int, Action)
 	 */
 	public void addButton(AbstractButton button)
 	{
 		addButton(buttons.size(), button);
 	}
 
 	/**
 	 * Adds a button activating the specified action to the component at the
 	 * index specified.
 	 *
 	 * @param index
 	 * @param action
 	 *
 	 * @see #addButton(int, AbstractButton)
 	 */
 	public void addActionButton(int index, Action action)
 	{
 		if (buttons.contains(action.getValue(BUTTON_KEY))) {
 			buttons.add(index, (AbstractButton) action.getValue(BUTTON_KEY));
 			buttons.remove(action.getValue(BUTTON_KEY));
 
 			return;
 		}
 
 		AbstractButton tempButt = Actions.createButton(action);
 		tempButt.setText("");
 		tempButt.setToolTipText((String)action.getValue(Action.NAME));
 
 		if (action.getValue(Action.SMALL_ICON) != null) {
 			tempButt.setIcon((Icon)action.getValue(Action.SMALL_ICON));
 		}
 
 		action.addPropertyChangeListener(new PropertyChangeListener() {
 				public void propertyChange(PropertyChangeEvent evt)
 				{
 					if (evt.getPropertyName().equals(ACTION_VISIBLE)) {
 						revalidate();
 						repaint();
 					}
 				}
 			});
 
 		addButton(index, tempButt);
 		action.putValue(BUTTON_KEY, tempButt);
 	}
 
 	/**
 	 * Adds a button activating the specified action to the component.
 	 *
 	 * @param action
 	 *
 	 * @see #addButton(int, AbstractButton)
 	 */
 	public void addActionButton(Action action)
 	{
 		addActionButton(buttons.size(), action);
 	}
 
 	/**
 	 * Removes the specified button from this title bar.
 	 *
 	 * @param button The button to be removed.
 	 */
 	public void removeButton(AbstractButton button)
 	{
 		if (button != null) {
 			remove(button);
 			buttons.remove(button);
 		}
 	}
 
 	/**
 	 * Returns <code>true</code> if this title  button contains specified
 	 * button.
 	 *
 	 * @param button The button to be tested for containment
 	 *
 	 * @return <code>true</code> if button is on this title panel
 	 */
 	public boolean containsButton(AbstractButton button)
 	{
 		return buttons.contains(button);
 	}
 
 	/**
 	 * Removes the button connected to the specified action from this title
 	 * bar.
 	 *
 	 * @param action The button to be removed.
 	 */
 	public void removeActionButton(Action action)
 	{
 		removeButton((JButton)action.getValue(BUTTON_KEY));
 		revalidate();
 		repaint();
 	}
 
 	/**
 	 * Returns <code>true</code> if this title  button contains specified
 	 * action.
 	 *
 	 * @param action The action to be tested for containment
 	 *
 	 * @return <code>true</code> if action is on this title panel
 	 */
 	public boolean containsAction(Action action)
 	{
 		return containsButton((JButton)action.getValue(BUTTON_KEY));
 	}
 
 	private void initialize(int heigth)
 	{
 		setOpaque(true);
 		setBorder(CosyUIElements.getPlainBorder(true));
 		setLayout(titleBarLayout = new PanelTitleBarLayout(heigth));
 		setFocusable(true);
 		addFocusListener(new FocusAdapter() {
 				public void focusGained(FocusEvent event)
 				{
 					if (buttons.size() < 1) {
 						setSelectedButton(null);
 
 						if (event.getOppositeComponent() == getFocusCycleRootAncestor()
 						    .getFocusTraversalPolicy().getComponentAfter(getFocusCycleRootAncestor(),
 						        PanelTitleBar.this)) {
 							PanelTitleBar.this.transferFocusBackward();
 						} else {
 							PanelTitleBar.this.transferFocus();
 						}
 					} else {
 						setSelectedButton(buttons.get(buttons.size() - 1));
 					}
 				}
 
 				public void focusLost(FocusEvent event)
 				{
 					if (!mouseIn) {
 						setSelectedButton(null);
 					}
 				}
 			});
 		addKeyListener(new KeyAdapter() {
 				public void keyPressed(KeyEvent event)
 				{
 					if (event.getKeyCode() == KeyEvent.VK_LEFT) {
 						moveSelectedLeft();
 					} else if (event.getKeyCode() == KeyEvent.VK_RIGHT) {
 						moveSelectedRight();
 					} else if (event.getKeyCode() == KeyEvent.VK_SPACE) {
 						actionSelected();
 					}
 				}
 			});
 		getInsets().bottom = 0;
 		getInsets().right = 0;
 		getInsets().top = 0;
 		getInsets().left = 0;
 
 		setBackground(ColorHelper.getTextHighlight());
 		setBackgroundStart(ColorHelper.getFocus());
 		title.setFont(title.getFont().deriveFont(Font.PLAIN));
 		title.setBorder(new Border() {
 				/**
 				 * @see javax.swing.border.Border#isBorderOpaque()
 				 */
 				public boolean isBorderOpaque()
 				{
 					return false;
 				}
 
 				/**
 				 * @see javax.swing.border.Border#getBorderInsets(Component)
 				 */
 				public Insets getBorderInsets(Component c)
 				{
 					return new Insets(0, 4, 0, 0);
 				}
 
 				/**
 				 * @see javax.swing.border.Border#paintBorder(Component,
 				 *      Graphics, int, int, int, int)
 				 */
 				public void paintBorder(Component c, Graphics g, int x, int y,
 				    int width, int height)
 				{
 					// nothing to do
 				}
 			});
 		title.setOpaque(true);
 		add(title, "Title");
 		revalidate();
 		repaint();
 	}
 
 	private void moveSelectedRight()
 	{
 		if (buttons.size() > 0) {
 			int newIdx = selectedIndex;
 			AbstractButton newButton;
 
 			do {
 				newIdx--;
 
 				if (newIdx < 0) {
 					newIdx = buttons.size() - 1;
 				}
 			} while (!((newButton = buttons.get(newIdx))
 			    .isEnabled() || newIdx == selectedIndex));
 
 			setSelectedButton(newButton);
 		}
 	}
 
 	private void moveSelectedLeft()
 	{
 		if (buttons.size() > 0) {
 			int newIdx = selectedIndex;
 			AbstractButton newButton;
 
 			do {
 				newIdx++;
 
 				if (newIdx >= buttons.size()) {
 					newIdx = 0;
 				}
 			} while (!((newButton = buttons.get(newIdx))
 			    .isEnabled() || newIdx == selectedIndex));
 
 			setSelectedButton(newButton);
 		}
 	}
 
 	private void actionSelected()
 	{
 		if ((selectedIndex > -1) && (selectedIndex < buttons.size())) {
 			((JButton)buttons.get(selectedIndex)).doClick(100);
 		}
 	}
 
 	/**
 	 * Sets the state of this title bar. If <code>active</code> parameter is
 	 * true, the background will be changed to the Metal L&F's focus color,
 	 * otherwise it will be changed to the window title background color.
 	 *
 	 * @param active The flag determining the state of the title bar.
 	 */
 	public void setActive(boolean active)
 	{
 		if (active) {
 			title.setOpaque(true);
 		} else {
 			title.setOpaque(false);
 		}
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @return DOCUMENT ME!
 	 */
 	public GradientLabel getTitleLabel()
 	{
 		return title;
 	}
 
 	protected ArrayList getButtonsList()
 	{
 		return buttons;
 	}
 
 	/**
 	 * Returns the color used for active background.
 	 *
 	 * @return Color
 	 */
 	public Color getBackgroundStart()
 	{
 		return title.getBackgroundStart();
 	}
 
 	/**
 	 * Returns the color used for active background.
 	 *
 	 * @param c The color that should be used as the background for active
 	 *        PanelTitleBar
 	 */
 	public void setBackgroundStart(Color c)
 	{
 		title.setBackgroundStart(c);
 	}
 
 	/**
 	 * Sets the background colors for the component.
 	 *
 	 * @param backgroundStart The color used for left part of the component
 	 *        when active
 	 * @param background The color used for right part of active background and
 	 *        inactive background.
 	 */
 	public void setBackground(Color backgroundStart, Color background)
 	{
 		setBackground(background);
 		title.setBackgroundStart(backgroundStart);
 	}
 
 	/**
 	 * Sets the background color of inactive title bar and the right color of
 	 * an active title bar.
 	 *
 	 * @see #setBackgroundStart(Color)
 	 */
 	public void setBackground(Color c)
 	{
 		super.setBackground(c);
 
 		if (title != null) {
 			title.setBackground(c);
 		}
 
 		if (buttons != null) {
 			for (Iterator iter = buttons.iterator(); iter.hasNext();) {
 				AbstractButton element = (AbstractButton)iter.next();
 				element.setBackground(c);
 			}
 		}
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @return Border
 	 */
 	public Border getOverBorder()
 	{
 		return overBorder;
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @return Border
 	 */
 	public Border getPressedBorder()
 	{
 		return pressedBorder;
 	}
 
 	/**
 	 * Sets the overBorder.
 	 *
 	 * @param overBorder The overBorder to set
 	 */
 	public void setOverBorder(Border overBorder)
 	{
 		this.overBorder = overBorder;
 
 		if (buttons != null) {
 			for (Iterator iter = buttons.iterator(); iter.hasNext();) {
 				AbstractButton element = (AbstractButton)iter.next();
 
 				if (!element.isSelected()) {
 					element.setBorder(overBorder);
 				}
 			}
 		}
 	}
 
 	/**
 	 * Sets the pressedBorder.
 	 *
 	 * @param pressedBorder The pressedBorder to set
 	 */
 	public void setPressedBorder(Border pressedBorder)
 	{
 		this.pressedBorder = pressedBorder;
 
 		if (buttons != null) {
 			for (Iterator iter = buttons.iterator(); iter.hasNext();) {
 				AbstractButton element = (AbstractButton)iter.next();
 
 				if (element.isSelected()) {
 					element.setBorder(pressedBorder);
 				}
 			}
 		}
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param act
 	 *
 	 * @return
 	 */
 	public boolean hasAction(Action act)
 	{
 		AbstractButton[] buts = new AbstractButton[buttons.size()];
 		buttons.toArray(buts);
 
 		for (int i = 0; i < buts.length; i++) {
 			if (act.equals(buts[i].getAction())) {
 				return true;
 			}
 		}
 
 		return false;
 	}
 
 	/**
 	 * Returns the higth of panel with the title bar.
 	 *
 	 * @return Returns the title bar height.
 	 */
 	public int getTitleBarHeight()
 	{
 		return titleBarLayout.getHeight();
 	}
 
 	/**
 	 * Sets the higth of panel with the title bar.
 	 *
 	 * @param titleBarHeight The title bar height to set.
 	 */
 	void setTitleBarHeight(int titleBarHeight)
 	{
 		titleBarLayout.setHeight(titleBarHeight);
 	}
 }
 
 /* __oOo__ */