Back to index...

	/*
	* Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code 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
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	package javax.swing.plaf.synth;

	import java.awt.*;
	import java.awt.event.*;
	import javax.swing.*;
	import javax.swing.plaf.*;
	import javax.swing.plaf.basic.BasicSpinnerUI;
	import java.beans.*;

	/**
	* Provides the Synth L&F UI delegate for
	* {@link javax.swing.JSpinner}.
	*
	* @author Hans Muller
	* @author Joshua Outwater
	* @since 1.7
	*/
	public class SynthSpinnerUI extends BasicSpinnerUI
	implements PropertyChangeListener, SynthUI {
	private SynthStyle style;
	/**
	* A FocusListener implementation which causes the entire spinner to be
	* repainted whenever the editor component (typically a text field) becomes
	* focused, or loses focus. This is necessary because since SynthSpinnerUI
	* is composed of an editor and two buttons, it is necessary that all three
	* components indicate that they are "focused" so that they can be drawn
	* appropriately. The repaint is used to ensure that the buttons are drawn
	* in the new focused or unfocused state, mirroring that of the editor.
	*/
	private EditorFocusHandler editorFocusHandler = new EditorFocusHandler();

	/**
	* Returns a new instance of SynthSpinnerUI.
	*
	* @param c the JSpinner (not used)
	* @see ComponentUI#createUI
	* @return a new SynthSpinnerUI object
	*/
	public static ComponentUI createUI(JComponent c) {
	return new SynthSpinnerUI();
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	protected void installListeners() {
	super.installListeners();
	spinner.addPropertyChangeListener(this);
	JComponent editor = spinner.getEditor();
	if (editor instanceof JSpinner.DefaultEditor) {
	JTextField tf = ((JSpinner.DefaultEditor)editor).getTextField();
	if (tf != null) {
	tf.addFocusListener(editorFocusHandler);
	}
	}
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	protected void uninstallListeners() {
	super.uninstallListeners();
	spinner.removePropertyChangeListener(this);
	JComponent editor = spinner.getEditor();
	if (editor instanceof JSpinner.DefaultEditor) {
	JTextField tf = ((JSpinner.DefaultEditor)editor).getTextField();
	if (tf != null) {
	tf.removeFocusListener(editorFocusHandler);
	}
	}
	}

	/**
	* Initializes the <code>JSpinner</code> <code>border</code>,
	* <code>foreground</code>, and <code>background</code>, properties
	* based on the corresponding "Spinner.*" properties from defaults table.
	* The <code>JSpinners</code> layout is set to the value returned by
	* <code>createLayout</code>. This method is called by <code>installUI</code>.
	*
	* @see #uninstallDefaults
	* @see #installUI
	* @see #createLayout
	* @see LookAndFeel#installBorder
	* @see LookAndFeel#installColors
	*/
	@Override
	protected void installDefaults() {
	LayoutManager layout = spinner.getLayout();

	if (layout == null \|\| layout instanceof UIResource) {
	spinner.setLayout(createLayout());
	}
	updateStyle(spinner);
	}


	private void updateStyle(JSpinner c) {
	SynthContext context = getContext(c, ENABLED);
	SynthStyle oldStyle = style;
	style = SynthLookAndFeel.updateStyle(context, this);
	if (style != oldStyle) {
	if (oldStyle != null) {
	// Only call installKeyboardActions as uninstall is not
	// public.
	installKeyboardActions();
	}
	}
	context.dispose();
	}


	/**
	* Sets the <code>JSpinner's</code> layout manager to null. This
	* method is called by <code>uninstallUI</code>.
	*
	* @see #installDefaults
	* @see #uninstallUI
	*/
	@Override
	protected void uninstallDefaults() {
	if (spinner.getLayout() instanceof UIResource) {
	spinner.setLayout(null);
	}

	SynthContext context = getContext(spinner, ENABLED);

	style.uninstallDefaults(context);
	context.dispose();
	style = null;
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	protected LayoutManager createLayout() {
	return new SpinnerLayout();
	}


	/**
	* {@inheritDoc}
	*/
	@Override
	protected Component createPreviousButton() {
	JButton b = new SynthArrowButton(SwingConstants.SOUTH);
	b.setName("Spinner.previousButton");
	installPreviousButtonListeners(b);
	return b;
	}


	/**
	* {@inheritDoc}
	*/
	@Override
	protected Component createNextButton() {
	JButton b = new SynthArrowButton(SwingConstants.NORTH);
	b.setName("Spinner.nextButton");
	installNextButtonListeners(b);
	return b;
	}


	/**
	* This method is called by installUI to get the editor component
	* of the <code>JSpinner</code>. By default it just returns
	* <code>JSpinner.getEditor()</code>. Subclasses can override
	* <code>createEditor</code> to return a component that contains
	* the spinner's editor or null, if they're going to handle adding
	* the editor to the <code>JSpinner</code> in an
	* <code>installUI</code> override.
	* <p>
	* Typically this method would be overridden to wrap the editor
	* with a container with a custom border, since one can't assume
	* that the editors border can be set directly.
	* <p>
	* The <code>replaceEditor</code> method is called when the spinners
	* editor is changed with <code>JSpinner.setEditor</code>. If you've
	* overriden this method, then you'll probably want to override
	* <code>replaceEditor</code> as well.
	*
	* @return the JSpinners editor JComponent, spinner.getEditor() by default
	* @see #installUI
	* @see #replaceEditor
	* @see JSpinner#getEditor
	*/
	@Override
	protected JComponent createEditor() {
	JComponent editor = spinner.getEditor();
	editor.setName("Spinner.editor");
	updateEditorAlignment(editor);
	return editor;
	}


	/**
	* Called by the <code>PropertyChangeListener</code> when the
	* <code>JSpinner</code> editor property changes. It's the responsibility
	* of this method to remove the old editor and add the new one. By
	* default this operation is just:
	* <pre>
	* spinner.remove(oldEditor);
	* spinner.add(newEditor, "Editor");
	* </pre>
	* The implementation of <code>replaceEditor</code> should be coordinated
	* with the <code>createEditor</code> method.
	*
	* @see #createEditor
	* @see #createPropertyChangeListener
	*/
	@Override
	protected void replaceEditor(JComponent oldEditor, JComponent newEditor) {
	spinner.remove(oldEditor);
	spinner.add(newEditor, "Editor");
	if (oldEditor instanceof JSpinner.DefaultEditor) {
	JTextField tf = ((JSpinner.DefaultEditor)oldEditor).getTextField();
	if (tf != null) {
	tf.removeFocusListener(editorFocusHandler);
	}
	}
	if (newEditor instanceof JSpinner.DefaultEditor) {
	JTextField tf = ((JSpinner.DefaultEditor)newEditor).getTextField();
	if (tf != null) {
	tf.addFocusListener(editorFocusHandler);
	}
	}
	}

	private void updateEditorAlignment(JComponent editor) {
	if (editor instanceof JSpinner.DefaultEditor) {
	SynthContext context = getContext(spinner);
	Integer alignment = (Integer)context.getStyle().get(
	context, "Spinner.editorAlignment");
	JTextField text = ((JSpinner.DefaultEditor)editor).getTextField();
	if (alignment != null) {
	text.setHorizontalAlignment(alignment);

	}
	// copy across the sizeVariant property to the editor
	text.putClientProperty("JComponent.sizeVariant",
	spinner.getClientProperty("JComponent.sizeVariant"));
	}
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	public SynthContext getContext(JComponent c) {
	return getContext(c, SynthLookAndFeel.getComponentState(c));
	}

	private SynthContext getContext(JComponent c, int state) {
	return SynthContext.getContext(c, style, state);
	}

	/**
	* Notifies this UI delegate to repaint the specified component.
	* This method paints the component background, then calls
	* the {@link #paint(SynthContext,Graphics)} method.
	*
	* <p>In general, this method does not need to be overridden by subclasses.
	* All Look and Feel rendering code should reside in the {@code paint} method.
	*
	* @param g the {@code Graphics} object used for painting
	* @param c the component being painted
	* @see #paint(SynthContext,Graphics)
	*/
	@Override
	public void update(Graphics g, JComponent c) {
	SynthContext context = getContext(c);

	SynthLookAndFeel.update(context, g);
	context.getPainter().paintSpinnerBackground(context,
	g, 0, 0, c.getWidth(), c.getHeight());
	paint(context, g);
	context.dispose();
	}


	/**
	* Paints the specified component according to the Look and Feel.
	* <p>This method is not used by Synth Look and Feel.
	* Painting is handled by the {@link #paint(SynthContext,Graphics)} method.
	*
	* @param g the {@code Graphics} object used for painting
	* @param c the component being painted
	* @see #paint(SynthContext,Graphics)
	*/
	@Override
	public void paint(Graphics g, JComponent c) {
	SynthContext context = getContext(c);

	paint(context, g);
	context.dispose();
	}

	/**
	* Paints the specified component. This implementation does nothing.
	*
	* @param context context for the component being painted
	* @param g the {@code Graphics} object used for painting
	* @see #update(Graphics,JComponent)
	*/
	protected void paint(SynthContext context, Graphics g) {
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	public void paintBorder(SynthContext context, Graphics g, int x,
	int y, int w, int h) {
	context.getPainter().paintSpinnerBorder(context, g, x, y, w, h);
	}

	/**
	* A simple layout manager for the editor and the next/previous buttons.
	* See the SynthSpinnerUI javadoc for more information about exactly
	* how the components are arranged.
	*/
	private static class SpinnerLayout implements LayoutManager, UIResource
	{
	private Component nextButton = null;
	private Component previousButton = null;
	private Component editor = null;

	public void addLayoutComponent(String name, Component c) {
	if ("Next".equals(name)) {
	nextButton = c;
	}
	else if ("Previous".equals(name)) {
	previousButton = c;
	}
	else if ("Editor".equals(name)) {
	editor = c;
	}
	}

	public void removeLayoutComponent(Component c) {
	if (c == nextButton) {
	nextButton = null;
	}
	else if (c == previousButton) {
	previousButton = null;
	}
	else if (c == editor) {
	editor = null;
	}
	}

	private Dimension preferredSize(Component c) {
	return (c == null) ? new Dimension(0, 0) : c.getPreferredSize();
	}

	public Dimension preferredLayoutSize(Container parent) {
	Dimension nextD = preferredSize(nextButton);
	Dimension previousD = preferredSize(previousButton);
	Dimension editorD = preferredSize(editor);

	/* Force the editors height to be a multiple of 2
	*/
	editorD.height = ((editorD.height + 1) / 2) * 2;

	Dimension size = new Dimension(editorD.width, editorD.height);
	size.width += Math.max(nextD.width, previousD.width);
	Insets insets = parent.getInsets();
	size.width += insets.left + insets.right;
	size.height += insets.top + insets.bottom;
	return size;
	}

	public Dimension minimumLayoutSize(Container parent) {
	return preferredLayoutSize(parent);
	}

	private void setBounds(Component c, int x, int y, int width, int height) {
	if (c != null) {
	c.setBounds(x, y, width, height);
	}
	}

	public void layoutContainer(Container parent) {
	Insets insets = parent.getInsets();
	int availWidth = parent.getWidth() - (insets.left + insets.right);
	int availHeight = parent.getHeight() - (insets.top + insets.bottom);
	Dimension nextD = preferredSize(nextButton);
	Dimension previousD = preferredSize(previousButton);
	int nextHeight = availHeight / 2;
	int previousHeight = availHeight - nextHeight;
	int buttonsWidth = Math.max(nextD.width, previousD.width);
	int editorWidth = availWidth - buttonsWidth;

	/* Deal with the spinners componentOrientation property.
	*/
	int editorX, buttonsX;
	if (parent.getComponentOrientation().isLeftToRight()) {
	editorX = insets.left;
	buttonsX = editorX + editorWidth;
	}
	else {
	buttonsX = insets.left;
	editorX = buttonsX + buttonsWidth;
	}

	int previousY = insets.top + nextHeight;
	setBounds(editor, editorX, insets.top, editorWidth, availHeight);
	setBounds(nextButton, buttonsX, insets.top, buttonsWidth, nextHeight);
	setBounds(previousButton, buttonsX, previousY, buttonsWidth, previousHeight);
	}
	}

	/**
	* {@inheritDoc}
	*/
	@Override
	public void propertyChange(PropertyChangeEvent e) {
	JSpinner spinner = (JSpinner)(e.getSource());
	SpinnerUI spinnerUI = spinner.getUI();

	if (spinnerUI instanceof SynthSpinnerUI) {
	SynthSpinnerUI ui = (SynthSpinnerUI)spinnerUI;

	if (SynthLookAndFeel.shouldUpdateStyle(e)) {
	ui.updateStyle(spinner);
	}
	}
	}

	/** Listen to editor text field focus changes and repaint whole spinner */
	private class EditorFocusHandler implements FocusListener{
	/** Invoked when a editor text field gains the keyboard focus. */
	@Override public void focusGained(FocusEvent e) {
	spinner.repaint();
	}

	/** Invoked when a editor text field loses the keyboard focus. */
	@Override public void focusLost(FocusEvent e) {
	spinner.repaint();
	}
	}
	}

Back to index...