mirror of git://gcc.gnu.org/git/gcc.git
562 lines
15 KiB
Java
562 lines
15 KiB
Java
/* BasicSpinnerUI.java --
|
|
Copyright (C) 2003, 2004, 2005, 2006, Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU Classpath.
|
|
|
|
GNU Classpath 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 2, or (at your option)
|
|
any later version.
|
|
|
|
GNU Classpath 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 GNU Classpath; see the file COPYING. If not, write to the
|
|
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
02110-1301 USA.
|
|
|
|
Linking this library statically or dynamically with other modules is
|
|
making a combined work based on this library. Thus, the terms and
|
|
conditions of the GNU General Public License cover the whole
|
|
combination.
|
|
|
|
As a special exception, the copyright holders of this library give you
|
|
permission to link this library with independent modules to produce an
|
|
executable, regardless of the license terms of these independent
|
|
modules, and to copy and distribute the resulting executable under
|
|
terms of your choice, provided that you also meet, for each linked
|
|
independent module, the terms and conditions of the license of that
|
|
module. An independent module is a module which is not derived from
|
|
or based on this library. If you modify this library, you may extend
|
|
this exception to your version of the library, but you are not
|
|
obligated to do so. If you do not wish to do so, delete this
|
|
exception statement from your version. */
|
|
|
|
|
|
package javax.swing.plaf.basic;
|
|
|
|
import java.awt.Component;
|
|
import java.awt.Container;
|
|
import java.awt.Dimension;
|
|
import java.awt.Insets;
|
|
import java.awt.LayoutManager;
|
|
import java.awt.event.ActionEvent;
|
|
import java.awt.event.ActionListener;
|
|
import java.awt.event.MouseAdapter;
|
|
import java.awt.event.MouseEvent;
|
|
import java.beans.PropertyChangeEvent;
|
|
import java.beans.PropertyChangeListener;
|
|
|
|
import javax.swing.JButton;
|
|
import javax.swing.JComponent;
|
|
import javax.swing.JSpinner;
|
|
import javax.swing.LookAndFeel;
|
|
import javax.swing.Timer;
|
|
import javax.swing.plaf.ComponentUI;
|
|
import javax.swing.plaf.SpinnerUI;
|
|
|
|
/**
|
|
* A UI delegate for the {@link JSpinner} component.
|
|
*
|
|
* @author Ka-Hing Cheung
|
|
*
|
|
* @since 1.4
|
|
*/
|
|
public class BasicSpinnerUI extends SpinnerUI
|
|
{
|
|
/**
|
|
* Creates a new <code>BasicSpinnerUI</code> for the specified
|
|
* <code>JComponent</code>
|
|
*
|
|
* @param c the component (ignored).
|
|
*
|
|
* @return A new instance of {@link BasicSpinnerUI}.
|
|
*/
|
|
public static ComponentUI createUI(JComponent c)
|
|
{
|
|
return new BasicSpinnerUI();
|
|
}
|
|
|
|
/**
|
|
* Creates an editor component. Really, it just returns
|
|
* <code>JSpinner.getEditor()</code>
|
|
*
|
|
* @return a JComponent as an editor
|
|
*
|
|
* @see javax.swing.JSpinner#getEditor
|
|
*/
|
|
protected JComponent createEditor()
|
|
{
|
|
return spinner.getEditor();
|
|
}
|
|
|
|
/**
|
|
* Creates a <code>LayoutManager</code> that layouts the sub components. The
|
|
* subcomponents are identifies by the constraint "Next", "Previous" and
|
|
* "Editor"
|
|
*
|
|
* @return a LayoutManager
|
|
*
|
|
* @see java.awt.LayoutManager
|
|
*/
|
|
protected LayoutManager createLayout()
|
|
{
|
|
return new DefaultLayoutManager();
|
|
}
|
|
|
|
/**
|
|
* Creates the "Next" button
|
|
*
|
|
* @return the next button component
|
|
*/
|
|
protected Component createNextButton()
|
|
{
|
|
JButton button = new BasicArrowButton(BasicArrowButton.NORTH);
|
|
return button;
|
|
}
|
|
|
|
/**
|
|
* Creates the "Previous" button
|
|
*
|
|
* @return the previous button component
|
|
*/
|
|
protected Component createPreviousButton()
|
|
{
|
|
JButton button = new BasicArrowButton(BasicArrowButton.SOUTH);
|
|
return button;
|
|
}
|
|
|
|
/**
|
|
* Creates the <code>PropertyChangeListener</code> that will be attached by
|
|
* <code>installListeners</code>. It should watch for the "editor"
|
|
* property, when it's changed, replace the old editor with the new one,
|
|
* probably by calling <code>replaceEditor</code>
|
|
*
|
|
* @return a PropertyChangeListener
|
|
*
|
|
* @see #replaceEditor
|
|
*/
|
|
protected PropertyChangeListener createPropertyChangeListener()
|
|
{
|
|
return new PropertyChangeListener()
|
|
{
|
|
public void propertyChange(PropertyChangeEvent event)
|
|
{
|
|
// FIXME: Add check for enabled property change. Need to
|
|
// disable the buttons.
|
|
if ("editor".equals(event.getPropertyName()))
|
|
BasicSpinnerUI.this.replaceEditor((JComponent) event.getOldValue(),
|
|
(JComponent) event.getNewValue());
|
|
// FIXME: Handle 'font' property change
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Called by <code>installUI</code>. This should set various defaults
|
|
* obtained from <code>UIManager.getLookAndFeelDefaults</code>, as well as
|
|
* set the layout obtained from <code>createLayout</code>
|
|
*
|
|
* @see javax.swing.UIManager#getLookAndFeelDefaults
|
|
* @see #createLayout
|
|
* @see #installUI
|
|
*/
|
|
protected void installDefaults()
|
|
{
|
|
LookAndFeel.installColorsAndFont(spinner, "Spinner.background",
|
|
"Spinner.foreground", "Spinner.font");
|
|
LookAndFeel.installBorder(spinner, "Spinner.border");
|
|
JComponent e = spinner.getEditor();
|
|
if (e instanceof JSpinner.DefaultEditor)
|
|
{
|
|
JSpinner.DefaultEditor de = (JSpinner.DefaultEditor) e;
|
|
de.getTextField().setBorder(null);
|
|
}
|
|
spinner.setLayout(createLayout());
|
|
spinner.setOpaque(true);
|
|
}
|
|
|
|
/*
|
|
* Called by <code>installUI</code>, which basically adds the
|
|
* <code>PropertyChangeListener</code> created by
|
|
* <code>createPropertyChangeListener</code>
|
|
*
|
|
* @see #createPropertyChangeListener
|
|
* @see #installUI
|
|
*/
|
|
protected void installListeners()
|
|
{
|
|
spinner.addPropertyChangeListener(listener);
|
|
}
|
|
|
|
/*
|
|
* Install listeners to the next button so that it increments the model
|
|
*/
|
|
protected void installNextButtonListeners(Component c)
|
|
{
|
|
c.addMouseListener(new MouseAdapter()
|
|
{
|
|
public void mousePressed(MouseEvent evt)
|
|
{
|
|
if (! spinner.isEnabled())
|
|
return;
|
|
increment();
|
|
timer.setInitialDelay(500);
|
|
timer.start();
|
|
}
|
|
|
|
public void mouseReleased(MouseEvent evt)
|
|
{
|
|
timer.stop();
|
|
}
|
|
|
|
void increment()
|
|
{
|
|
Object next = BasicSpinnerUI.this.spinner.getNextValue();
|
|
if (next != null)
|
|
BasicSpinnerUI.this.spinner.getModel().setValue(next);
|
|
}
|
|
|
|
volatile boolean mouseDown;
|
|
Timer timer = new Timer(50,
|
|
new ActionListener()
|
|
{
|
|
public void actionPerformed(ActionEvent event)
|
|
{
|
|
increment();
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
/*
|
|
* Install listeners to the previous button so that it decrements the model
|
|
*/
|
|
protected void installPreviousButtonListeners(Component c)
|
|
{
|
|
c.addMouseListener(new MouseAdapter()
|
|
{
|
|
public void mousePressed(MouseEvent evt)
|
|
{
|
|
if (! spinner.isEnabled())
|
|
return;
|
|
decrement();
|
|
timer.setInitialDelay(500);
|
|
timer.start();
|
|
}
|
|
|
|
public void mouseReleased(MouseEvent evt)
|
|
{
|
|
timer.stop();
|
|
}
|
|
|
|
void decrement()
|
|
{
|
|
Object prev = BasicSpinnerUI.this.spinner.getPreviousValue();
|
|
if (prev != null)
|
|
BasicSpinnerUI.this.spinner.getModel().setValue(prev);
|
|
}
|
|
|
|
volatile boolean mouseDown;
|
|
Timer timer = new Timer(50,
|
|
new ActionListener()
|
|
{
|
|
public void actionPerformed(ActionEvent event)
|
|
{
|
|
decrement();
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Install this UI to the <code>JComponent</code>, which in reality, is a
|
|
* <code>JSpinner</code>. Calls <code>installDefaults</code>,
|
|
* <code>installListeners</code>, and also adds the buttons and editor.
|
|
*
|
|
* @param c DOCUMENT ME!
|
|
*
|
|
* @see #installDefaults
|
|
* @see #installListeners
|
|
* @see #createNextButton
|
|
* @see #createPreviousButton
|
|
* @see #createEditor
|
|
*/
|
|
public void installUI(JComponent c)
|
|
{
|
|
super.installUI(c);
|
|
|
|
spinner = (JSpinner) c;
|
|
|
|
installDefaults();
|
|
installListeners();
|
|
|
|
Component next = createNextButton();
|
|
Component previous = createPreviousButton();
|
|
|
|
installNextButtonListeners(next);
|
|
installPreviousButtonListeners(previous);
|
|
|
|
c.add(createEditor(), "Editor");
|
|
c.add(next, "Next");
|
|
c.add(previous, "Previous");
|
|
}
|
|
|
|
/**
|
|
* Replace the old editor with the new one
|
|
*
|
|
* @param oldEditor the old editor
|
|
* @param newEditor the new one to replace with
|
|
*/
|
|
protected void replaceEditor(JComponent oldEditor, JComponent newEditor)
|
|
{
|
|
spinner.remove(oldEditor);
|
|
spinner.add(newEditor);
|
|
}
|
|
|
|
/**
|
|
* The reverse of <code>installDefaults</code>. Called by
|
|
* <code>uninstallUI</code>
|
|
*/
|
|
protected void uninstallDefaults()
|
|
{
|
|
spinner.setLayout(null);
|
|
}
|
|
|
|
/**
|
|
* The reverse of <code>installListeners</code>, called by
|
|
* <code>uninstallUI</code>
|
|
*/
|
|
protected void uninstallListeners()
|
|
{
|
|
spinner.removePropertyChangeListener(listener);
|
|
}
|
|
|
|
/**
|
|
* Called when the current L&F is replaced with another one, should call
|
|
* <code>uninstallDefaults</code> and <code>uninstallListeners</code> as
|
|
* well as remove the next/previous buttons and the editor
|
|
*
|
|
* @param c DOCUMENT ME!
|
|
*/
|
|
public void uninstallUI(JComponent c)
|
|
{
|
|
super.uninstallUI(c);
|
|
|
|
uninstallDefaults();
|
|
uninstallListeners();
|
|
c.removeAll();
|
|
}
|
|
|
|
/** The spinner for this UI */
|
|
protected JSpinner spinner;
|
|
|
|
/** DOCUMENT ME! */
|
|
private PropertyChangeListener listener = createPropertyChangeListener();
|
|
|
|
/**
|
|
* A layout manager for the {@link JSpinner} component. The spinner has
|
|
* three subcomponents: an editor, a 'next' button and a 'previous' button.
|
|
*/
|
|
private class DefaultLayoutManager implements LayoutManager
|
|
{
|
|
/**
|
|
* Layout the spinners inner parts.
|
|
*
|
|
* @param parent The parent container
|
|
*/
|
|
public void layoutContainer(Container parent)
|
|
{
|
|
synchronized (parent.getTreeLock())
|
|
{
|
|
Insets i = parent.getInsets();
|
|
boolean l2r = parent.getComponentOrientation().isLeftToRight();
|
|
/*
|
|
-------------- --------------
|
|
| | n | | n | |
|
|
| e | - | or | - | e |
|
|
| | p | | p | |
|
|
-------------- --------------
|
|
*/
|
|
Dimension e = prefSize(editor);
|
|
Dimension n = prefSize(next);
|
|
Dimension p = prefSize(previous);
|
|
Dimension s = parent.getSize();
|
|
|
|
int x = l2r ? i.left : i.right;
|
|
int y = i.top;
|
|
int w = Math.max(p.width, n.width);
|
|
int h = (s.height - i.bottom) / 2;
|
|
int e_width = s.width - w - i.left - i.right;
|
|
|
|
if (l2r)
|
|
{
|
|
setBounds(editor, x, y, e_width, 2 * h);
|
|
x += e_width;
|
|
setBounds(next, x, y, w, h);
|
|
y += h;
|
|
setBounds(previous, x, y, w, h);
|
|
}
|
|
else
|
|
{
|
|
setBounds(next, x, y + (s.height - e.height) / 2, w, h);
|
|
y += h;
|
|
setBounds(previous, x, y + (s.height - e.height) / 2, w, h);
|
|
x += w;
|
|
y -= h;
|
|
setBounds(editor, x, y, e_width, e.height);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calculates the minimum layout size.
|
|
*
|
|
* @param parent the parent.
|
|
*
|
|
* @return The minimum layout size.
|
|
*/
|
|
public Dimension minimumLayoutSize(Container parent)
|
|
{
|
|
Dimension d = new Dimension();
|
|
|
|
if (editor != null)
|
|
{
|
|
Dimension tmp = editor.getMinimumSize();
|
|
d.width += tmp.width;
|
|
d.height = tmp.height;
|
|
}
|
|
|
|
int nextWidth = 0;
|
|
int previousWidth = 0;
|
|
|
|
if (next != null)
|
|
{
|
|
Dimension tmp = next.getMinimumSize();
|
|
nextWidth = tmp.width;
|
|
}
|
|
if (previous != null)
|
|
{
|
|
Dimension tmp = previous.getMinimumSize();
|
|
previousWidth = tmp.width;
|
|
}
|
|
|
|
d.width += Math.max(nextWidth, previousWidth);
|
|
|
|
return d;
|
|
}
|
|
|
|
/**
|
|
* Returns the preferred layout size of the container.
|
|
*
|
|
* @param parent DOCUMENT ME!
|
|
*
|
|
* @return DOCUMENT ME!
|
|
*/
|
|
public Dimension preferredLayoutSize(Container parent)
|
|
{
|
|
Dimension d = new Dimension();
|
|
|
|
if (editor != null)
|
|
{
|
|
Dimension tmp = editor.getPreferredSize();
|
|
d.width += Math.max(tmp.width, 40);
|
|
d.height = tmp.height;
|
|
}
|
|
|
|
int nextWidth = 0;
|
|
int previousWidth = 0;
|
|
|
|
if (next != null)
|
|
{
|
|
Dimension tmp = next.getPreferredSize();
|
|
nextWidth = tmp.width;
|
|
}
|
|
if (previous != null)
|
|
{
|
|
Dimension tmp = previous.getPreferredSize();
|
|
previousWidth = tmp.width;
|
|
}
|
|
|
|
d.width += Math.max(nextWidth, previousWidth);
|
|
Insets insets = parent.getInsets();
|
|
d.width = d.width + insets.left + insets.right;
|
|
d.height = d.height + insets.top + insets.bottom;
|
|
return d;
|
|
}
|
|
|
|
/**
|
|
* DOCUMENT ME!
|
|
*
|
|
* @param child DOCUMENT ME!
|
|
*/
|
|
public void removeLayoutComponent(Component child)
|
|
{
|
|
if (child == editor)
|
|
editor = null;
|
|
else if (child == next)
|
|
next = null;
|
|
else if (previous == child)
|
|
previous = null;
|
|
}
|
|
|
|
/**
|
|
* DOCUMENT ME!
|
|
*
|
|
* @param name DOCUMENT ME!
|
|
* @param child DOCUMENT ME!
|
|
*/
|
|
public void addLayoutComponent(String name, Component child)
|
|
{
|
|
if ("Editor".equals(name))
|
|
editor = child;
|
|
else if ("Next".equals(name))
|
|
next = child;
|
|
else if ("Previous".equals(name))
|
|
previous = child;
|
|
}
|
|
|
|
/**
|
|
* DOCUMENT ME!
|
|
*
|
|
* @param c DOCUMENT ME!
|
|
*
|
|
* @return DOCUMENT ME!
|
|
*/
|
|
private Dimension prefSize(Component c)
|
|
{
|
|
if (c == null)
|
|
return new Dimension();
|
|
else
|
|
return c.getPreferredSize();
|
|
}
|
|
|
|
/**
|
|
* Sets the bounds for the specified component.
|
|
*
|
|
* @param c the component.
|
|
* @param x the x-coordinate for the top-left of the component bounds.
|
|
* @param y the y-coordinate for the top-left of the component bounds.
|
|
* @param w the width of the bounds.
|
|
* @param h the height of the bounds.
|
|
*/
|
|
private void setBounds(Component c, int x, int y, int w, int h)
|
|
{
|
|
if (c != null)
|
|
c.setBounds(x, y, w, h);
|
|
}
|
|
|
|
/** The editor component. */
|
|
private Component editor;
|
|
|
|
/** The next button. */
|
|
private Component next;
|
|
|
|
/** The previous button. */
|
|
private Component previous;
|
|
}
|
|
}
|