Min und Max für SpinnerListModel

[SuperFamicom]

Hallo,

Ich möchte zwei JSpinner sich gegenseitig bedingen lassen. Der aktuelle Wert des ersten JSpinners soll das Minimum des zweiten JSpinners sein. Andersrum hat der aktuelle Wert des zweiten JSpinners das Maximum des ersten JSpinners zu sein.

Das ganze wäre sicherlich trivial für SpinnerNumberModel, allerdings muss ich die JSpinner über SpinnerListModel laufen lassen. Gibt es die Möglichkeit (und wenn ja wie) ähnlich wie für SpinnerNumberModel, Minimum und Maximum über die Array-Indizes zu definieren und die jeweiligen JSpinner davon abhängig zu machen?

Natürlich könnte man als weniger elegante Lösung nach jedem ChangeEvent der JSpinner zwei Sub-Arrays erzeugen lassen und diese als neue Arrays an beide JSpinner übergeben. Allerdings hab ich Befürchtungen, dass es gerade bei großen Datensätzen (mehrere hunderttausende Array-Elemente), die es durchzurattern gilt, zu erheblichen Performance-Einbußen kommen könnte.

Einfacher wäre es, nach jedem ChangeEvent einfach nur Min- und Max-Werte für die Array-Indizes der jeweiligen JSpinner neu zu setzen.

Ich hoffe, hier kann jemand aushelfen.

 

[Lodoss]

Verstehe ich das richtig, SpinA.wert soll immer < SpinB.wert sein, und SpinB.wert soll immer > SpinA.wert sein? Dann hab ich was für dich:

package SpinnerDemo;

import java.awt.Dimension;
import java.awt.FlowLayout;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

import javax.swing.JFrame;
import javax.swing.JSpinner;
import javax.swing.SpinnerListModel;
import javax.swing.SwingUtilities;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

public class DependSpinners extends JFrame 
{
	private List<String> elements = new ArrayList<String>();
	private JSpinner spinA;
	private JSpinner spinB;
	
	private Comparator<String> elementComparator = new Comparator<String>()
	{
		@Override
		public int compare(String o1, String o2)
		{
			return elements.indexOf(o1) - elements.indexOf(o2);
		}
	};
	
	public static void main(String[] args)
	{
		new DependSpinners();
	}
	
	public DependSpinners()
	{
		elements.add("A");
		elements.add("B");
		elements.add("C");
		
		SpinnerListModel slmA = new SpinnerListModel(elements);
		spinA = new JSpinner(slmA);
		
		spinA.addChangeListener(new ChangeListener()
		{
			@Override
			public void stateChanged(final ChangeEvent e)
			{
				int compResult = elementComparator.compare(
						spinA.getValue().toString(), 
						spinB.getValue().toString());
				
				if (compResult > 0)
				{
					SwingUtilities.invokeLater(new Runnable()
					{
						@Override
						public void run()
						{
							spinA.setValue(elements.get(elements.indexOf(spinA.getValue().toString())-1));
						}
					});
				}
			}
		});

		SpinnerListModel slmB = new SpinnerListModel(elements);
		spinB = new JSpinner(slmB);
		
		spinB.addChangeListener(new ChangeListener()
		{
			@Override
			public void stateChanged(final ChangeEvent e)
			{
				int compResult = elementComparator.compare(
						spinA.getValue().toString(), 
						spinB.getValue().toString());
				
				if (compResult > 0)
				{
					SwingUtilities.invokeLater(new Runnable()
					{
						@Override
						public void run()
						{
							spinB.setValue(elements.get(elements.indexOf(spinB.getValue().toString())+1));
						}
					});
				}
			}
		});
		
		this.setSize(new Dimension(500,500));
		this.setLayout(new FlowLayout());
		
		this.add(spinA);
		this.add(spinB);
		
		this.setVisible(true);
	}
}

der comparator dient dazu, die "Werte" der Spinner zu vergleichen (das können strings, idx's oder zahlen oder sonstwas sein). die beiden Changelistener machen die Änderungen je nach Aussage, ob wert von SpinA > SpinB bzw SpinB > SpinA wieder rückgängig