JPanel wird erst durch aufziehen des Fensters sichtbar

[Zuecho]

Guten Abend zusammen,
ich bin momentan dabei ein Sudoku-Spiel zu programmieren.
Das ganze ist mein erstes etwas größeres Projekt und auch mein erster Versuch eine Grafische Obergläche einzubauen.

Im Grunde habe ich bisher alles ganz gut umgesetzt bekommen, das Spiel ist eigentlich auch soweit grob fertig. Leider hab ich noch ein paar Schönheitsfehler, welche ich nun auch nach ewigen Probieren nicht wegbekommen habe. Evtl. könnt ihr mir ja helfen.

Problem 1:
Wenn ich das Spiel starte, wird ab und zu mein JPanel, in welchem ich das 9x9-Sudokufeld liegen habe, falsch oder gar nicht angezeigt. Wenn ich allerdings meinen JFrame per Maus ein wenig auf- oder zuziehe erscheint das JPanel mit dem Raster.
Das ganze tritt manchmal bei jedem 10., manchaml aber auch bei jedem 2. programmstart auf.

Problem 2:
Wenn ich nun im Spiel "Neues Spiel" drücke soll eine Anfangsbelegung in das 9x9-Raster eingetragen werden. Diese wird aber auch erst angezeigt, nachdem ich den JFrame auf- oder zuziehe.

Evtl ist es ja sogar das gleiche Problem. Ich kann aber leider nichts finden.
Ich habe hier mal eine etwas abgespeckte Version meines Spiel für euch:

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

/**
 * @author Zuecho
 *
 */
public class Mini_aufziehProblem2 {
	
    static final int 		_GROESSE = 9;
    static Spielfeld 		_spielfeld;
    static JFrame 			_frame;
    static JPanel 			_oben;
    static JPanel 			_mitte;
    static JTextField[][] 	_textfeld;
    static JButton 			_buttonHilfe;
    static JButton 			_buttonLoesen;

    /**
     * Konstruktor
     * 
     * Der Konstruktor initialisiert die GUI und das Spielfeld
     */
	public Mini_aufziehProblem2() {
		oberflaeche();
	}

	/**
	 * Diese Main-Methode startet das Spiel
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		@SuppressWarnings("unused")
		Mini_aufziehProblem2 losgehts = new Mini_aufziehProblem2();
	}
	
    /**
     * Initialisiert die GUI
     */
    private static void oberflaeche() {
        _frame = new JFrame();
        _frame.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); 
        _frame.setVisible(true);
        _frame.setSize(500, 550);
        _frame.setLayout( new BorderLayout() );
        
        _oben = new JPanel();
        
        JButton buttonNeu = new JButton("Neues Spiel");
        _oben.add( buttonNeu );
        buttonNeu.addActionListener( new ActionListener() {
        	@Override public void actionPerformed( ActionEvent ae ) {  
        		resetSpielflaeche();
        		_spielfeld = new Spielfeld();
        		spielflaeche();
        		schreibeFeld();
        		_buttonHilfe.setEnabled(true);
        		_buttonLoesen.setEnabled(true);
        	}
        });
        
        _buttonHilfe = new JButton("Hilfe");
        _oben.add( _buttonHilfe );
        _buttonHilfe.setEnabled(false);
        _buttonHilfe.addActionListener( new ActionListener() {
        	@Override public void actionPerformed( ActionEvent ae ) {
       
        	}
        } );
        
        _buttonLoesen = new JButton("Lösen");
        _oben.add(  _buttonLoesen );
        _buttonLoesen.setEnabled(false);
        _buttonLoesen.addActionListener( new ActionListener() {
        	@Override public void actionPerformed( ActionEvent ae ) {

        	}
        } );
        
        JButton buttonSchließen = new JButton("Schließen");
        _oben.add( buttonSchließen );
        buttonSchließen.addActionListener( new ActionListener() {
        	@Override public void actionPerformed( ActionEvent ae ) {
        		System.exit( 0 );
        	}
        });
        
        _frame.add(_oben, BorderLayout.PAGE_START);
        _oben.setVisible(true);
        
        
        _mitte = new JPanel();
        _mitte.setLayout( new GridLayout(9,9));
        _mitte.setSize(500, 500);
        _mitte.setVisible(true);
        _frame.add(_mitte, BorderLayout.CENTER);
        
        spielflaeche();
    }
    
    /**
     * Erstellt die Spielfläche mit dem Gitter
     */
    private static void spielflaeche() {
    	_textfeld = new JTextField[_GROESSE][_GROESSE];
    	
        for (int zeile = 0; zeile < _GROESSE; ++zeile) {
            for (int spalte = 0; spalte < _GROESSE; ++spalte) {
            	
            	// Erzeuge und formatiere JTextField
                _textfeld[zeile][spalte] = new JTextField();
                _textfeld[zeile][spalte].setHorizontalAlignment(JTextField.CENTER);
                _textfeld[zeile][spalte].setFont( new Font("Arial", Font.BOLD, 24) );
                
                // Erzeuge Ränder
                int unten=1;
                int rechts=1;
                if ( zeile == 2 || zeile == 5 ) {
                	unten = 3;
                }
                if ( spalte == 2 || spalte == 5 ) {
                	rechts = 3;
                }          	
                _textfeld[zeile][spalte].setBorder(BorderFactory.createMatteBorder(0, 0, unten, rechts, Color.BLACK));
                
                // Erzeuge ActionListener auf jeden Textfeld
                _textfeld[zeile][spalte].addActionListener( new ActionListener() {
                	@Override public void actionPerformed( ActionEvent ae ){

                	}
                });
                
                _mitte.add( _textfeld[zeile][spalte] );
            }
        }
    }
    
    /**
     * Diese Methode beschreibt ein Feld mit dem aktuellen Wert
     * und formatiert das Textfeld
     * 
     * @param zeile
     * @param spalte
     */
    private static void schreibeZelle(int zeile, int spalte) {
    	int wert = _spielfeld.gibZelle(zeile, spalte);
    	
    	// Textfeld beschriften
        if ( wert >= 1 && wert <= 9 ) {
          	_textfeld[zeile][spalte].setText( Integer.toString(wert) );
        }
        else {
        	_textfeld[zeile][spalte].setText( "" );
        }
        
        // Vorbelegte Felder formatieren
        if (_spielfeld.gibZelleVorbelegung(zeile, spalte) == true) {
        	  _textfeld[zeile][spalte].setEditable(false);
        }
        
        System.out.println("neu gemalt!");
    }
    
    /**
     * Diese Methode setzt alle Textfelder 
     */
    private static void schreibeFeld() {
        for (int zeile = 0; zeile < _GROESSE; ++zeile) {
            for (int spalte = 0; spalte < _GROESSE; ++spalte) {
            	schreibeZelle(zeile,spalte);
            }
        }
    }
    
    /**
     * Entfernt die Spielfläche
     */
    private static void resetSpielflaeche() {
    	_mitte.removeAll();
    }
    
}

Klasse Spielfeld()

/**
 * Diese Klasse erzeugt ein neues Sudokufeld, kann dieses Verändern und lösen
 * 
 * @author 
 * @version Feb. 2010
 */
public class Spielfeld
{
    int[][] _spielfeld;
    int[][] _loesungsfeld;
    int[][] _farbfeld;
    boolean[][] _vorbelegung;
    Startfelder _startfeld;
    int _groesse = 9;
    int _anzahlHilfe = 0;

    
    /**
     * Der Konstruktor initialisert ein neues Spielfeld und belegt dies mit Startwerten.
     * Ausserdem werden die weiteren Zustandsfelder belegt.
     */
    public Spielfeld() {
        _startfeld = new Startfelder();
        _spielfeld = new int[_groesse][_groesse];
        _loesungsfeld = new int[_groesse][_groesse];
        _vorbelegung = new boolean[_groesse][_groesse];
        _farbfeld = new int[_groesse][_groesse];  // 0: schwarz, 1: rot, 2: blau, 3: grün
        
        setUp();
    }
    
    /**
     * Diese Methode initialisiert das Spielfeld.
     * Dabei wird:
     *  - das _spielfeld mit einem Startfeld belegt
     *  - das _vorgegeben Feld initialisiert
     */
    private void setUp() {
    	// _spielfeld mit _startfeld belegen
    	_spielfeld = _startfeld.gibStartfeld().clone();
        int wert = 0;
        for (int zeile = 0; zeile < _groesse; ++zeile) {
            for (int spalte = 0; spalte < _groesse; ++spalte)
            {
            	wert = _startfeld.gibStartfeld()[zeile][spalte];
            	_spielfeld[zeile][spalte] = wert;
            }
        }
    	
    	// _vorbelegung belegen
        for (int zeile = 0; zeile < _groesse; ++zeile) {
            for (int spalte = 0; spalte < _groesse; ++spalte)
            {
                if (_spielfeld[zeile][spalte]!=-1) {
                	_vorbelegung[zeile][spalte] = true;
                }
            }
        }

	}
    
  
  
    /**
     * Gibt das Feld mit allen Feldbelegungen wieder
     * 
     * @return _spielfeld int[][] mit allen Feldbelegungen
     * 					  nicht belegtes Feld: -1
     */
    public int[][] gibSpielfeld() {
    	return _spielfeld;
    }
   
    /**
     * Gibt das Farb-/Vorbelegungsfeld als int[][]
     * 
     * @return _farbfeld int[][]
     */
    public int[][] gibFarbfeld() {
    	return _farbfeld;
    }
    
    /**
     * Gibt die Anzahl der bereits verbrauchten Lösungshilfen wieder
     * 
     * @return _anzahlHilfe int: Anzahl bereits Hilfe benutzt
     */
    public int gibAnzahlHilfe() {
    	return _anzahlHilfe;
    }
    
    /**
     * Gibt den Spielwert einer einzelnen Zelle
     * 
     * @return wert 
     */
    public int gibZelle(int zeile, int spalte) {
    	return _spielfeld[zeile][spalte];
    }
    
    /**
     * Gibt true, falls das Feld zur Startbelegung gehört
     * 
     * @return vorbelegung
     */
    public boolean gibZelleVorbelegung(int zeile, int spalte) {
    	return _vorbelegung[zeile][spalte];
    }
    
    /**
     * Gibt die Farbe einer einzelnen Zelle
     * 
     * @return farbwert
     */
    public int gibZelleFarbe(int zeile, int spalte) {
    	return _farbfeld[zeile][spalte];
    }
}

Klasse Startfelder()

/**
 * Deiese Klasse liefert eine Startbelegung für das Spielfeld
 * 
 * @author 
 * @version Februar 2010
 */
public class Startfelder {

    int[][] _startfeld;
    int _groesse = 9;

    /**
     * Initialisiert ein Startfeld
     */
    public Startfelder() {
        _startfeld = new int[_groesse][_groesse];
        for (int zeile = 0; zeile < _groesse; ++zeile)
        {
            for (int spalte = 0; spalte < _groesse; ++spalte)
            {
                _startfeld[zeile][spalte] = -1;
            }
        }
    }
    
    
    /**
     * Gibt das fertig initialisierte Feld als Int-Array zurück
     */
    public int[][] gibStartfeld() {
        initialisiereStartfeld();
        return _startfeld;
    }
    
    
     /**
     * Belegt das Startfeld mit einer Startaufstellung
     */
    private void initialisiereStartfeld() {
      _startfeld[0][0] = 1 ;
      _startfeld[0][4] = 2 ;
      _startfeld[0][6] = 7 ;
      _startfeld[0][7] = 5 ;

      _startfeld[1][0] = 6 ;
      _startfeld[1][4] = 5 ;
      _startfeld[1][7] = 4 ;

      _startfeld[2][1] = 2 ;
      _startfeld[2][3] = 4 ;
      _startfeld[2][7] = 1 ;

      _startfeld[3][0] = 2 ;
      _startfeld[3][2] = 8 ;

      _startfeld[4][1] = 7 ;
      _startfeld[4][3] = 5 ;
      _startfeld[4][5] = 9 ;
      _startfeld[4][7] = 6 ;

      _startfeld[5][6] = 4 ;
      _startfeld[5][8] = 1 ;

      _startfeld[6][1] = 1 ;
      _startfeld[6][5] = 5 ;
      _startfeld[6][7] = 8 ;

      _startfeld[7][1] = 9 ;
      _startfeld[7][4] = 7 ;
      _startfeld[7][8] = 4 ;

      _startfeld[8][1] = 8 ;
      _startfeld[8][2] = 2 ;
      _startfeld[8][4] = 4 ;
      _startfeld[8][8] = 5 ;
    }
}

Vielen Dank schonmal für eure Mühe!

 

[Dow Jones]

Ich habe den Code jetzt nicht großartig studiert, aber versuch mal JFrame.pack() aufzurufen. Vielleicht reicht das schon.

 

[Zuecho]

JFrame.pack() behebt zwar das Problem, führt aber zu neuen, da jetzt das Sudokufeld nicht mehr quadratisch ist und auch das ganze Fenster zu klein wird.

Allerdings funktioniert es, wenn ich _frame.validate() in Zeile 137 einfüge.
Die genaue Funktion von validate() ist mir jedoch noch nicht ganz klar.

Ich hab aber noch ein kleines weiteres Problem:
Ich habe ja die Buttons oben sowie das 9x9-Gitter mit BorderLayout im JFrame angeordnet.
Das 9x9-Gitter ist dabei in ein JPanel eingebettet, was wiederrum im Center des JFrames sitzt.
Allerdings wird das JPanel mit dem 9x9-Gitter nicht horizontal zentriert eingesetzt.
Links schließt dieses genau an den Frame an und rechts sind 3-4 px Freiraum.
Kann mir jemand sagen, wie ich das beheben kann?
Gehts das überhaupt mit BorderLayout?

Danke und Gruß,
Zuecho

 

[Marco13]

Ohne Rand kann man das wohl nur darstellen, wenn die Größe durch 9 teilbar ist. Ansonsten bräuchte man ggf. einen eigenen LayoutManager