Hallo Leute,
Ich weiss nicht ob das eine Anfängerfrage ist oder ob ich hier richtig bin... ???:L
Ziel ist ein Sudoku und das Problem liegt in der Window Klasse. Diese erhält ein zweidimensionales Array des Types Cell (ebenfalls eine Klasse von mir), indem die Daten des Spiels gespeichert sind. Eine Zelle kann folgende Daten speichern: Einen Wert (int), ein isLocked (boolean) und eine Farbe (Color).
Das Array heisst cellHolder[][] und wird der Window Klasse bei initialisieren übergeben. Bis dahin und noch ein wenig weiter klappt ja auch alles ganz gut, aus irgenwelchen Gründen reagiert jedoch der ActionListener der Buttons nicht. In der Konsole wird ein angezeigt, dass der Knopf gedrückt wurde aber der GUI ändert sich nicht.
Kann mir jemand helfen?
*******************************************************************************
Die Cell Klasse
ah ja der Solver funktioniert auch nocht nicht, aber den kann ich wahrscheindlich auch selber noch zum laufen bringen. :wink:
Besten Dank schon im Voraus
[/quote]
Ich weiss nicht ob das eine Anfängerfrage ist oder ob ich hier richtig bin... ???:L
Ziel ist ein Sudoku und das Problem liegt in der Window Klasse. Diese erhält ein zweidimensionales Array des Types Cell (ebenfalls eine Klasse von mir), indem die Daten des Spiels gespeichert sind. Eine Zelle kann folgende Daten speichern: Einen Wert (int), ein isLocked (boolean) und eine Farbe (Color).
Das Array heisst cellHolder[][] und wird der Window Klasse bei initialisieren übergeben. Bis dahin und noch ein wenig weiter klappt ja auch alles ganz gut, aus irgenwelchen Gründen reagiert jedoch der ActionListener der Buttons nicht. In der Konsole wird ein angezeigt, dass der Knopf gedrückt wurde aber der GUI ändert sich nicht.
Kann mir jemand helfen?
Code:
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;
import javax.swing.Action;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
public class Window extends JFrame implements ActionListener
{
private Cell cellHolder[][];
private JButton[][] buttons;
private int dimensions[] = {4, 9, 16};
private Random random;
private JButton setLock;
private JButton solveIt;
private JButton clearAll;
private JFrame fester;
private JPanel grid;
private JPanel functionButtons;
private JLabel rechts;
private JLabel oben;
private Action a;
private int zahl1;
private int zahl2;
private int menuSize = 8;
public Window(final Cell cellHolder[][])
{
this.cellHolder = cellHolder;
// Frame erstellen
final JFrame fenster = new JFrame("Sudoku (Grid)");
// Definiert wo das Fenster auf dem Bildschirn angezeigt wird.
setLocation(300, 200);
setSize(300, 300);
// Menü oben erstellen
// Button erstellen
JButton neu = new JButton("Neues Spiel");
neu.setToolTipText("<html>Startet ein neues Spiel
(Achtung! Alle eingegebenen Daten gehen verloren)</html>");
fenster.getContentPane().add(neu);
ActionListener aNeu = new ActionListener() // aNeu = ActionListener für Neu
{
public void actionPerformed(ActionEvent e)
{
new Thread(new Runnable()
{
public void run()
{
System.out.println("ButtonEvent: Button \"neues Spiel\" wurde gedrückt");
for (int i = 0; i < cellHolder.length; i++)
{
for (int j = 0; j < cellHolder.length; j++)
{
cellHolder[i][j].setValue(0);
cellHolder[i][j].setLocked(false);
}
}
}
}).start();
}
};
neu.addActionListener(aNeu);
JButton neuOfLocked = new JButton("Spiel nochmals starten");
neuOfLocked.setToolTipText("<html>Startet ein vorher gespeichertes
Spiel noch einmal</html>");
fenster.getContentPane().add(neuOfLocked);
ActionListener aNeuOfLocked = new ActionListener() // aNeuOfLocked = ActionListener für neues Spiel der gelockten Cells
{
public void actionPerformed(ActionEvent e)
{
System.out.println("ButtonEvent: Button \"Spiel neu starten\" wurde gedrückt");
new Thread(new Runnable()
{
public void run()
{
for (int i = 0; i < cellHolder.length; i++)
{
for (int j = 0; j < cellHolder.length; j++)
{
if (cellHolder[i][j].isLocked() == false)
{
cellHolder[i][j].setValue(0);
}
}
}
}
}).start();
}
};
neuOfLocked.addActionListener(aNeuOfLocked);
JButton exit = new JButton("Spiel beenden");
exit.setToolTipText("Beendet das Spiel");
fenster.getContentPane().add(exit);
ActionListener aExit = new ActionListener() // aExit = ActionListener für Exit
{
public void actionPerformed(ActionEvent e)
{
System.out.println("ButtonEvent: Button \"Spiel beenden\" wurde gedrückt");
System.exit(1);
}
};
exit.addActionListener(aExit);
// Panel erstellen
JPanel menuOben = new JPanel();
menuOben.setLayout(new GridLayout(0, 3));
// Buttons auf Panel packen
menuOben.add(neu);
menuOben.add(neuOfLocked);
menuOben.add(exit);
// Menu rechts erstellen
// Buttons erstellen
JButton set = new JButton("set");
set.setToolTipText("speichert das aktuelle Spiel.");
fenster.getContentPane().add(set);
ActionListener aSet = new ActionListener() // aSet = ActionListener für Set
{
public void actionPerformed(ActionEvent e)
{
System.out.println("ButtonEvent: Button Set wurde gedrückt, Cellen mit einem Value werden auf gelockt.");
new Thread(new Runnable()
{
public void run()
{
for (int i = 0; i < cellHolder.length; i++)
{
for (int j = 0; j < cellHolder.length; j++)
{
if (cellHolder[i][j].getValue() != 0)
{
cellHolder[i][j].setLocked(true);
}
}
}
System.out.println("ButtonEvent: printout of the Table according to the LockStatus:");
for (int i = 0; i < cellHolder.length; i++)
{
for (int j = 0; j < cellHolder.length; j++)
{
if (cellHolder[i][j].isLocked() == true)
{
System.out.print(" x");
}
else
{
System.out.print(" o");
}
}
System.out.println("");
}
}
}).start();
}
};
set.addActionListener(aSet);
JButton solve = new JButton("solve");
solve.setToolTipText("Löst das eingegebene Spiel");
fenster.getContentPane().add(solve);
ActionListener aSolve = new ActionListener() // aSolve = ActionListener für Solve
{
public void actionPerformed(ActionEvent e)
{
System.out.println("ButtonEvent: Button Solve wurde gedrückt");
for (int i = 0; i < cellHolder.length; i++)
{
for (int j = 0; j < cellHolder.length; j++)
{
Solver(cellHolder, i, j);
}
}
}
};
solve.addActionListener(aSolve);
JButton show = new JButton("show");
show.setToolTipText("<html>Nur für Programmierer
Gibt das Table auf der Console aus</html>.");
fenster.getContentPane().add(show);
ActionListener aShow = new ActionListener() // aShow = ActionListener für Show
{
public void actionPerformed(ActionEvent e)
{
System.out.println("ButtonEvent: Button Show wurde gedrückt, das grid soeht wie folgt aus:");
for (int i = 0; i < cellHolder.length; i++)
{
for (int j = 0; j < cellHolder.length; j++)
{
System.out.print(" "+cellHolder[i][j].getValue());
}
System.out.println();
}
}
};
show.addActionListener(aShow);
// Panel erstllen
JPanel menuRechts = new JPanel();
menuRechts.setLayout(new GridLayout(menuSize, 0)); //dynamisch, passt sich der Table grösse an.
// Buttons auf Panel packen
menuRechts.add(set);
menuRechts.add(solve);
menuRechts.add(show);
// Button erstellen und mit den Value der Zelle initialisieren, natürlich Variabel für die grösse des Spiels
System.out.println("generate Buttons for Field");
buttons = new JButton[this.cellHolder.length][this.cellHolder.length];
for (int i = 0; i < buttons.length; i++)
{
for (int j = 0; j < buttons.length; j++)
{
buttons[i][j] = new JButton("" + this.cellHolder[i][j].getValue());
buttons[i][j].setActionCommand("" + i + j);
buttons[i][j].setToolTipText("<html>Wert erhöhen
durch klicken.</html>");
}
}
// Panel erstellen
JPanel grid = new JPanel();
grid.setLayout(new GridLayout(this.cellHolder.length, this.cellHolder.length));
// Buttons auf Panel packen und ActionListener für Grid-Buttons erstellen
for (int i = 0; i < buttons.length; i++)
{
for (int j = 0; j < buttons.length; j++)
{
grid.add(buttons[i][j]);
buttons[i][j].addActionListener(this);
}
}
// Container erstellen und alles auf den Container packen
Container c = fenster.getContentPane();
c.setLayout(new BorderLayout(5, 5));
c.add(grid, BorderLayout.CENTER);
c.add(menuRechts, BorderLayout.EAST);
c.add(menuOben, BorderLayout.NORTH);
// Alles packen und fertigstellen
// Beim schliessen des Fensters -> Programm beenden
fenster.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
fenster.pack();
fenster.setVisible(true);
}
public void actionPerformed(final ActionEvent e)
{
// 1. erhöht den Wert der Cell um eins
// 2. kontrolliert mit logic.checkLine und logic.checkRow und logic.checkRegion ob eingabe richtig ist.
// 3. setzt Schriftfarbe auf blau, wenn alles ok, oder rot wenn es fehler gibt.
new Thread(new Runnable()
{
public void run()
{
for (int i = 0; i < cellHolder.length; i++)
{
for (int j = 0; j < cellHolder.length; j++)
{
if(e.getActionCommand().equals(""+i+j))
{
if (cellHolder[i][j].getValue() < cellHolder.length)
{
cellHolder[i][j].setValue(cellHolder[i][j].getValue()+1);
System.out.println("GridEvent: increment cell["+i+"]["+j+"] to new value of " + cellHolder[i][j].getValue());
}
else
{
cellHolder[i][j].setValue(0);
cellHolder[i][j].setValue(cellHolder[i][j].getValue()+1);
System.out.println("GridEvent: set to 0 and increment cell["+i+"]["+j+"] to new value of " + cellHolder[i][j].getValue());
}
}
}
}
}
}).start();
}
private void Solver(Cell cellHolder[][], int i, int j)
{
cellHolder[i][j].setValue(cellHolder[i][j].getValue() + 1);
Logic lg = new Logic(cellHolder, i, j);
if (lg.checkLine() && lg.checkRow() && lg.checkRegion())
{
System.out.println("Solver für ["+i+"]["+j+"] abgeschlossen.");
return;
}
System.out.println("Neuer Solver wird gestartet.");
Solver(cellHolder, i, j);
}
}*******************************************************************************
Die Cell Klasse
Code:
import java.awt.Color;
/** The Class which represents a Cell, this is the smallest Object in a Sudoku Game.
* When the Gametable is generated we instance a Cell-Object for every Cell in the Table.*/
public class Cell
{
private int value; //int Value of the Cell
private boolean isLocked; //boolean Value of the LockStatus
private Color color;
/** Constructor needs no parameters. (default Constructor)*/
public Cell()
{
;
}
/** This Method returns the LockStatus of the Cell
* @return isLocked Returns a boolean Value
true = Cell is Locked,
false = Cell is not Locked */
public boolean isLocked()
{
return isLocked;
}
/** This Method sets the LockStatus of the Cell
* @value isLocked The Boolean value of the LockStatus. true = is Locked, false = is not Locked. */
public void setLocked(boolean isLocked)
{
this.isLocked = isLocked;
}
/** This Method returns the Value of the Cell
* @return value This is the int Value of the Cell*/
public int getValue()
{
return value;
}
/** This Method sets the Value of the Cell
* @value value A int Value in the size of the Game <code>(game.getTable().cellHolder[][].lenght)</code>*/
public void setValue(int value)
{
this.value = value;
}
/** This Method returns the color the Cell has in the Grid(GUI)
* @return color the color the Cell has in the Grid.*/
public Color getColor()
{
return color;
}
/** THis Method sets the Color the Cell has in the Grid(GUI).
* @value color the color the Cell has in the Grid.*/
public void setColorBlue(Color color)
{
this.color = color;
}
}Besten Dank schon im Voraus
[/quote]
