actionListener für JButton "Step"

[widad]

Hallo Leute,
ich erstelle gerade eine GUI mit Java, und zwar mit drei Buttons Run, Halt und next. Mit Run beginnt der Thread zu laufen und Halt soll suspendiert werden.Beide laufen prima.
NextButton soll die Ausführung des Threads Step by Step durchführen.
Hat jemand eine Idee wie ich -buttonNext.addActionListener- implementieren kann.
Ich danke euch alle im Voraus.

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;


import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JPanel;
import javax.swing.JTextField;

/** verwende fuer Kommentare hier javadoc
 * @author adil
 *
 */
public class PanelAnimation extends JPanel  {
	
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	
	int cols ;
	Dimension panelAnimation ;
	JTextField[] tf;
	TextfieldArray vektor ;
	JButton buttonNext ,buttonHalt, buttonRun ;
	JPanel animationButton ;
	JPanel pane;
	boolean isFlagStart;
	String algorithmus;
	Algorithm algorithm;
	Thread thread ;
	public PanelAnimation(){
		thread = null;
		isFlagStart = false;
		animationButton = new JPanel();
		animationButton.setPreferredSize(new Dimension(600,40));
		animationButton.setBorder(BorderFactory.createLineBorder(Color.black));
		pane = new JPanel();
		pane.setPreferredSize(new Dimension(600,470));
		pane.setBorder(BorderFactory.createLineBorder(Color.black));
		setLayout(new BorderLayout());
		this.cols = PanelVektor.cols;
		this.tf = new JTextField[cols];
		this.vektor = new TextfieldArray(cols);
		panelAnimation = new Dimension(600,510);
		this.setPreferredSize(panelAnimation);
		this.setBorder(BorderFactory.createLineBorder(Color.black));
		
		Dimension buttonDimension = new Dimension(90,20); 
		
		buttonNext = new JButton("next");
		buttonNext.setPreferredSize(buttonDimension);
		
		buttonHalt = new JButton("halt");
		buttonHalt.setPreferredSize(buttonDimension);
		
		
		buttonRun  = new JButton("run");
		buttonRun.setPreferredSize(buttonDimension);
		buttonRun.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent e){
				if(thread == null){
					thread = new Thread()
						{	public void run(){
								if (Thread.interrupted())
								   return;
								try{
									if (StartFenster.animation.get_isFlagStart()){
										if(algorithmus == "Bubblesort"){
											algorithm = new BubbleSort(algorithmus,tf,pane);
											algorithm.sort(tf);
										}
										else if(algorithmus == "Insertionsort"){
											algorithm = new InsertSort(algorithmus,tf,pane);
											algorithm.sort(tf);
										}
										else if(algorithmus == "Selectionsort"){
											algorithm = new SelectSort(algorithmus,tf,pane);
											algorithm.sort(tf);
										}
										StartFenster.animation.set_isFlagStart(false);
									}
								}
								catch (Exception ex){
									ex.printStackTrace();
								} 
								finally {
									thread = null;
								}
							}
					};	
					thread.start();
				}
				else resumeNow();
			}
		 });
		buttonHalt.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            {
            	suspendNow();
            }
        });
		
		buttonNext.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent e)
            {
				
            }
		});
		
		animationButton.add(buttonNext);
		animationButton.add(buttonHalt);
		animationButton.add(buttonRun);
		
		this.add(animationButton, BorderLayout.SOUTH);
		
	}
	@SuppressWarnings("deprecation")
	private void suspendNow() {
	    if (thread != null) { // avoid NullPointerException
	      thread.suspend();
	    }
	  }
	@SuppressWarnings("deprecation")
	private void resumeNow() {
	    if (thread != null) { // avoid NullPointerException
	      thread.resume();
	    }
	  }
	@SuppressWarnings("deprecation")
	public void stopNow(){
		if(thread != null){
			thread.stop();
		}
	}
	public void setAlgorithmus(String algo){
		this.algorithmus = algo;
		
	}
	
	public void set_isFlagStart(boolean isORnot){
		this.isFlagStart = isORnot;
		
	}
	public boolean get_isFlagStart(){
		return isFlagStart;
	}
	public void remov(){
		
		pane.removeAll();
		this.revalidate();
		this.repaint();
	}
	public void ad(){
		vektor.setdata(tf);
		pane.add(vektor);
		this.add(pane , BorderLayout.CENTER);
		this.revalidate();
		this.repaint();
	}
	public void setdata(JTextField[] vektorData){
		for (int i = 0 ; i<cols ; i++){
			tf[i] = new JTextField("",3);
			tf[i].setHorizontalAlignment(JTextField.CENTER);
			tf[i].setText(vektorData[i].getText());
		}

	}
		

}

 

[Marco13]

Dass die Methoden aus "Thread" deprecated sind, hat einen Grund.
Es gäbe IMHO ganz grob zwei Möglichkeiten, wie man das steuern könnte: Entweder, die Algorithm's müssen ein Flag bekommen wie etwa ein "boolean singleStepMode", oder der Hauptthread muss in den Algorithmen statt 'sort' eben in einer Schleife immer nur eine Methode 'doOneSortStep' aufrufen.
Welche davon schöner wäre, ist schwer zu sagen - jegliche Form von Schönheit geht dort unter irgendwelchen wild herumgereichten JTextField-Arrays unter....

 

[widad]

vielen Dank für die Antwort. Herlich gesagt hätte ich mit dem Flag es weiterimplementieren, sonst muss ich jede menge im Programm ändern, wenn ich anstatt sort() die doOneStep() implementiere.
könntest du mir sagen wo ich den Flag im Algorithm setzen kann. als beispiel hier ist ein Algorithm

import javax.swing.JPanel;
import javax.swing.JTextField;


public class BubbleSort extends Algorithm{
	
	public BubbleSort (String alg,JTextField[] tf, JPanel pane){
		super(alg, tf ,pane);
	}
	
	public void sort(JTextField[] tf) throws InterruptedException{
			BubbleHilfVariablen hilfVariablen = new BubbleHilfVariablen();
			TextfieldArray[] vektor = new TextfieldArray[5];
			boolean flagAdd = true;
			int k =0; // für die 5 vektoren
			boolean unsortiert = true;
			//String unsort;
			int lenght = PanelVektor.cols;
			
			for (int i=0 ; i<5 ; i++){
				vektor[i] = new TextfieldArray(lenght);
				}
			//setdata(tf,vektor[0]);
			setdata(tf,vektor[4]);
			//pane.add(vektor[0]);
			pane.add(hilfVariablen);
			pane.add(vektor[4]);
			
			while (unsortiert && (lenght >=1)){
				StartFenster.panelCode.selectLine(3);
				Thread.sleep(500);
				StartFenster.panelCode.selectLine(4);
				unsortiert = false;
				hilfVariablen.setInHilfVar("false", 0); //unsortiert variable
				Thread.sleep(500);
				
				for (int i = 0 ; i < lenght-1 ; i++) {
					StartFenster.panelCode.selectLine(5);
					Thread.sleep(500);
							
					
					hilfVariablen.setInHilfVar(""+lenght, 1);//lenght variabele
					hilfVariablen.setInHilfVar(""+i,2);		//i variable
					Thread.sleep(500);
					
					//hilfVariablen.setInHilfVar("", 3);
					//selectline()in JTextPane
					StartFenster.panelCode.selectLine(6);
					
					hilfVariablen.setColorNull(3);
					vektor[4].setColorNull();
					vektor[4].setColor(i);
					vektor[4].setColor_c(i+1);
					
					if(Integer.parseInt(vektor[4].getAusArray(i)) > Integer.parseInt(vektor[4].getAusArray(i+1))){
						Thread.sleep(500);
						StartFenster.panelCode.selectLine(7);
						hilfVariablen.setColor(3);
						hilfVariablen.setInHilfVar(vektor[4].getAusArray(i), 3);
						Thread.sleep(500);
						
						StartFenster.panelCode.selectLine(8);
						vektor[4].setInArray(vektor[4].getAusArray(i+1), i);
						Thread.sleep(500);
						
						StartFenster.panelCode.selectLine(9);
						vektor[4].setInArray(hilfVariablen.getAusHilfVar(3), i+1);
						
						Thread.sleep(500);
						
						if(flagAdd){
							k++;
							copyData(vektor[4],vektor[k]);
							pane.add(vektor[k]);
							pane.add(hilfVariablen);
							pane.add(vektor[4]);
							StartFenster.animation.revalidate();
							StartFenster.animation.repaint();
							if(k == 3 ){
								flagAdd = false;
							}
						}
						else {
							pane.add(vektor[4]);
							for(int j = 1 ; j<4 ; j++ ){
								copyData(vektor[j],vektor[j-1]);
							}
							
							copyData(vektor[4],vektor[3]);
						}
						
						StartFenster.panelCode.selectLine(10);
						unsortiert = true;
						hilfVariablen.setInHilfVar("true", 0); //unsortiert variable
						Thread.sleep(500);
					}
					
				}
				StartFenster.panelCode.selectLine(13);
				Thread.sleep(500);
				lenght--;
				
			}
			StartFenster.panelCode.selectLine(14);
			Thread.sleep(500);
			
			StartFenster.panelCode.selectLine(15);
			Thread.sleep(500);	
		}// end von Bubblesort()
     }

viele Grüsse

 

[Marco13]

Hmjaa.. wie angedeutet: Das ist strukturell insgesamt jetzt nicht sooo schön.... aber wenn es nur darum geht, das so schnell wie möglich zum laufen zu kriegen... ein paar Codeschnipsel als halb-Pseudocode. Wie der "single step mode" genau gesteuert werden soll, hast du jetzt nicht gesagt. Man müßte dem Algorithmus am Anfang (also BEVOR man "sort" aufruft) sagen, dass er vor jedem Schritt warten soll, bis jemand "Next Step" klickt. Dann würde das ganz grob etwa so aussehen...:

class Algorithm
{
    private boolean singleStepMode = true; // Ggf. per setter auf 'true' gesetzt
    private boolean doStep= false;
    private Object monitor = new Object();

    public void sort(...)
    {
        ....
        while (unsortiert && (lenght >=1)) // Die "Hauptschleife": Jeder Durchlauf ist ein Schritt
        {

            // Im singleStepMode: Vor jedem Schritt warten
            if (singleStepMode)
            {
                synchronized (monitor)
                {
                    while (!doStep)
                    {
                        monitor.wait();
                    }
                }
            }


            // Hier die Sortierung wie bisher
            ...

            // Ggf. dafür sorgen, dass vor dem nächsten Schritt wieder gewartet wird...
            if (singleStepMode)
            {
                doStep = false;
            }
        }

        

    // Wird vom Button aufgerufen
    public void nextStep()
    {
        synchronized(monitor)
        {
            doStep = true;
            monitor.notify();
        }
    }

Ist nur schnell hingeschrieben, aber so grob müßt's passen...


EDIT: Je nach Algorithmus und je nachdem, was ein "Schritt" sein soll, könnte man die beiden if(singleStepMode)-Blöcke auch in eine weiter innen liegende Schleife legen (hier evtl. diese for-Schleife)

 

[widad]

hab vielen Dank, es ist genau was ich brauche. ich probiere deine Idee aus, und sage bescheid. Aber die Idee ist hervorragend.
nochmal danke

 

[widad]

jo danke , es hat geklappt .

public void synchronPanelAnimation() throws InterruptedException{
		if(stepMode){
			doStep = false;
			synchronized(monitor)
			{
				while(!doStep)  monitor.wait();
			}
		}
	}

diese Methode rufe ich sie auf , nachdem ich in JTextPane eine Zeile selktiere.
und beim Drücken auf Button next wird actionlistener aufgelöst.

buttonNext.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent e)
            {				 
				//doStep = false;
				stepMode = true;
				resumeNow();
				synchronized(monitor){
					doStep = true;
					monitor.notify();
				}
            }
		});