src/main/java/de/mannheim/th/chess/controller/ButtonMovePieceListener.java

@@ -27,16 +27,22 @@ public class ButtonMovePieceListener implements ActionListener {
     else
       this.game.playMove(this.mv);
 
+    this.game.setViewPointer(this.game.getMoveList().size() - 1);
+
     if (this.game.isDraw()) {
       this.game.stopClock();
       this.sf.setBoardMode(BoardMode.finished);
+      this.sf.enableControlPanelButtons();
       this.sf.showDraw();
     } else if (this.game.isMate()) {
       this.game.stopClock();
       this.sf.setBoardMode(BoardMode.finished);
+      this.sf.enableControlPanelButtons();
       this.sf.showWin(game.getActivePlayer());
-    }
+    } else {
       this.sf.setBoardMode(BoardMode.normal);
+    }
+
     this.sf.setCursor(null);
     this.sf.erstelleBrett();
 

src/main/java/de/mannheim/th/chess/controller/controlPanel/BaseButtonViewListener.java

@@ -0,0 +1,24 @@
+package de.mannheim.th.chess.controller.controlPanel;
+
+import de.mannheim.th.chess.ui.SpielFrame;
+import de.mannheim.th.chess.domain.Game;
+
+public abstract class BaseButtonViewListener {
+  protected SpielFrame sf;
+  protected Game game;
+
+  public BaseButtonViewListener(Game game, SpielFrame sf) {
+    this.sf = sf;
+    this.game = game;
+  }
+
+  /**
+   * Loads the gamestate and renders the board
+   */
+  protected void updateView() {
+    this.game.loadView();
+    this.sf.setDefaultButtons();
+    this.sf.applyBoardButtons();
+    this.sf.ladeBrett();
+  }
+}

src/main/java/de/mannheim/th/chess/controller/controlPanel/ButtonQuickloadListener.java

@@ -0,0 +1,24 @@
+package de.mannheim.th.chess.controller.controlPanel;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import de.mannheim.th.chess.domain.Game;
+import de.mannheim.th.chess.ui.SpielFrame;
+
+public class ButtonQuickloadListener implements ActionListener {
+  private Game game;
+  private SpielFrame sf;
+
+  public ButtonQuickloadListener(Game game, SpielFrame sf) {
+    this.game = game;
+    this.sf = sf;
+  }
+
+  @Override
+  public void actionPerformed(ActionEvent e) {
+    this.game.quickload();
+    this.sf.erstelleBrett();
+    this.sf.aktualisiereAusgabe();
+  }
+}

src/main/java/de/mannheim/th/chess/controller/controlPanel/ButtonQuicksaveListener.java

@@ -0,0 +1,19 @@
+package de.mannheim.th.chess.controller.controlPanel;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import de.mannheim.th.chess.domain.Game;
+
+public class ButtonQuicksaveListener implements ActionListener {
+  private Game game;
+
+  public ButtonQuicksaveListener(Game game) {
+    this.game = game;
+  }
+
+  @Override
+  public void actionPerformed(ActionEvent e) {
+    this.game.quicksave();
+  }
+}

src/main/java/de/mannheim/th/chess/controller/controlPanel/ButtonViewBackListener.java

@@ -0,0 +1,24 @@
+package de.mannheim.th.chess.controller.controlPanel;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import de.mannheim.th.chess.domain.Game;
+import de.mannheim.th.chess.ui.SpielFrame;
+
+public class ButtonViewBackListener extends BaseButtonViewListener implements ActionListener {
+
+  public ButtonViewBackListener(Game game, SpielFrame sf) {
+    super(game, sf);
+  }
+
+  @Override
+  public void actionPerformed(ActionEvent e) {
+    if (this.game.getViewPointer() > 0) {
+      this.game.setViewPointer(this.game.getViewPointer() - 1);
+      updateView();
+    }
+
+  }
+
+}

src/main/java/de/mannheim/th/chess/controller/controlPanel/ButtonViewFirstListener.java

@@ -0,0 +1,21 @@
+package de.mannheim.th.chess.controller.controlPanel;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import de.mannheim.th.chess.domain.Game;
+import de.mannheim.th.chess.ui.SpielFrame;
+
+public class ButtonViewFirstListener extends BaseButtonViewListener implements ActionListener {
+
+  public ButtonViewFirstListener(Game game, SpielFrame sf) {
+    super(game, sf);
+  }
+
+  @Override
+  public void actionPerformed(ActionEvent e) {
+    this.game.setViewPointer(0);
+    updateView();
+  }
+
+}

src/main/java/de/mannheim/th/chess/controller/controlPanel/ButtonViewForwardListener.java

@@ -0,0 +1,24 @@
+package de.mannheim.th.chess.controller.controlPanel;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import de.mannheim.th.chess.domain.Game;
+import de.mannheim.th.chess.ui.SpielFrame;
+
+public class ButtonViewForwardListener extends BaseButtonViewListener implements ActionListener {
+
+  public ButtonViewForwardListener(Game game, SpielFrame sf) {
+    super(game, sf);
+  }
+
+  @Override
+  public void actionPerformed(ActionEvent e) {
+    if (this.game.getMoveList().size() > this.game.getViewPointer()) {
+      this.game.setViewPointer(this.game.getViewPointer() + 1);
+      updateView();
+    }
+
+  }
+
+}

src/main/java/de/mannheim/th/chess/controller/controlPanel/ButtonViewLastListener.java

@@ -0,0 +1,22 @@
+
+package de.mannheim.th.chess.controller.controlPanel;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import de.mannheim.th.chess.domain.Game;
+import de.mannheim.th.chess.ui.SpielFrame;
+
+public class ButtonViewLastListener extends BaseButtonViewListener implements ActionListener {
+
+  public ButtonViewLastListener(Game game, SpielFrame sf) {
+    super(game, sf);
+  }
+
+  @Override
+  public void actionPerformed(ActionEvent e) {
+    this.game.setViewPointer(this.game.getMoveList().size());
+    updateView();
+  }
+
+}

src/main/java/de/mannheim/th/chess/domain/Game.java

@@ -16,7 +16,6 @@ import com.github.bhlangonijr.chesslib.move.MoveList;
 import com.github.bhlangonijr.chesslib.pgn.PgnHolder;
 
 import de.mannheim.th.chess.App;
-import de.mannheim.th.chess.ui.SpielFrame;
 import de.mannheim.th.chess.utl.Clock;
 
 /**
@@ -29,23 +28,28 @@ public class Game {
 
   private Board board;
   private Clock clock;
-  private SpielFrame sp;
   private String modus;
   private boolean rotieren, zuruecknahme;
 
   private MoveList movelist;
+  private int viewPointer;
 
-  public Game() {
-
-    this.board = new Board();
-    this.movelist = new MoveList();
-    clock = new Clock("blitz");
-    clock.start();
-  }
+  private MoveList savestate;
+  private String startPosFen;
 
   /**
    * Conststructs a new standard GameBoard.
    */
+  public Game() {
+
+    this.board = new Board();
+    this.movelist = new MoveList();
+    this.startPosFen = this.board.getFen();
+
+    clock = new Clock("blitz");
+    clock.start();
+  }
+
   public Game(String modus, boolean rotieren, boolean zuruecknahme, String fen) {
     this.modus = modus;
     this.rotieren = rotieren;
@@ -58,12 +62,10 @@ public class Game {
 
     this.board.loadFromFen(fen);
 
+    this.startPosFen = this.board.getFen();
     this.movelist = new MoveList();
 
     clock = new Clock(modus);
-
-    sp = new SpielFrame(this);
-
   }
 
   /**
@@ -74,14 +76,14 @@ public class Game {
   public Game(MoveList movelist) {
     this.board = new Board();
 
+    this.startPosFen = this.board.getFen();
     this.movelist = movelist;
 
     for (Move move : movelist) {
       this.board.doMove(move);
     }
 
-    // this.clockPlayer1 = new Clock();
-    // this.clockPlayer2 = new Clock();
+    this.clock = new Clock("blitz");
   }
 
   /**
@@ -94,6 +96,7 @@ public class Game {
     this.board.loadFromFen(fen);
 
     this.movelist = new MoveList();
+    this.startPosFen = this.board.getFen();
     // this.sp = new SpielFrame();
 
     // this.clockPlayer1 = new Clock();
@@ -123,6 +126,37 @@ public class Game {
     this.movelist.removeLast();
   }
 
+  /**
+   * Copies the current move list to the savestate
+   */
+  public void quicksave() {
+    // TODO: save the current clocktime
+    this.savestate = new MoveList(this.movelist);
+
+    logger.info("Quicksaved...");
+  }
+
+  /**
+   * Loads the save state
+   *
+   * @brief creates a new board with the startPosFen and then plays all the moves
+   *        from the savestate
+   */
+  public void quickload() {
+    if (this.savestate != null) {
+
+      this.board = new Board();
+      this.movelist.clear();
+      this.board.loadFromFen(startPosFen);
+
+      for (Move move : savestate) {
+        this.playMove(move);
+      }
+
+      logger.info("Quickloaded...");
+    }
+  }
+
   /**
    * Plays the move on the board and adds it to the movelist
    *
@@ -279,4 +313,26 @@ public class Game {
   public String getUnicodeFromMove(Move move) {
     return board.getPiece(move.getTo()).getFanSymbol().toUpperCase();
   }
+
+  public void setViewPointer(int i) {
+    this.viewPointer = i;
+  }
+
+  public int getViewPointer() {
+    return this.viewPointer;
+  }
+
+  /**
+   * Loads the current view
+   *
+   * @brief Creates a new gameboard from the start pos and playes moves until it
+   *        reaches the viewPointer
+   */
+  public void loadView() {
+    this.board = new Board();
+    this.board.loadFromFen(this.startPosFen);
+    for (int i = 0; i < this.viewPointer; i++) {
+      this.board.doMove(this.movelist.get(i));
+    }
+  }
 }

src/main/java/de/mannheim/th/chess/ui/MainFrame.java

@@ -8,6 +8,7 @@ import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
 import de.mannheim.th.chess.App;
+import de.mannheim.th.chess.domain.Game;
 
 import javax.swing.JLabel;
 
@@ -28,6 +29,7 @@ public class MainFrame extends JFrame {
 
   private static final long serialVersionUID = 1L;
   private JPanel contentPane;
+  private Game game;
 
   /**
    * Create the frame.
@@ -77,9 +79,7 @@ public class MainFrame extends JFrame {
 
       @Override
       public void actionPerformed(ActionEvent e) {
-
-				ModeSelectionFrame ms = new ModeSelectionFrame();
-
+        openSelectModeFrame();
       }
 
     });
@@ -87,6 +87,12 @@ public class MainFrame extends JFrame {
 
     contentPane.add(Box.createVerticalStrut(15));
 
+    JButton pgnLoaderButton = new JButton("Lade aus PGN Datei");
+    pgnLoaderButton.addActionListener(e -> openPgnSelectFrame());
+    contentPane.add(pgnLoaderButton);
+
+    contentPane.add(Box.createVerticalStrut(15));
+
     JButton btnNewButton_2 = new JButton("App beenden");
 
     btnNewButton_2.setBackground(Color.LIGHT_GRAY);
@@ -105,4 +111,44 @@ public class MainFrame extends JFrame {
     contentPane.add(btnNewButton_2);
     setVisible(true);
   }
+
+  /**
+   * Starts the spielframe and game in playmode
+   */
+  public void startGame() {
+    if (this.game != null) {
+      this.game.stopClock();
+      SpielFrame sf = new SpielFrame(this.game);
+    }
+  }
+
+  /**
+   * Starts the spielframe and game in view mode
+   */
+  public void startView() {
+    if (this.game != null) {
+      this.game.stopClock();
+      SpielFrame sf = new SpielFrame(this.game);
+      sf.setMode(SpielFrame.BoardMode.finished);
+      sf.enableControlPanelButtons();
+    }
+  }
+
+  public void setGame(Game game) {
+    this.game = game;
+  }
+
+  /**
+   * opens the selectmodeframe
+   */
+  private void openSelectModeFrame() {
+    new ModeSelectionFrame(this);
+  }
+
+  /**
+   * Opens the pgnselectorframe
+   */
+  private void openPgnSelectFrame() {
+    new PGNLoaderFrame(this);
+  }
 }

src/main/java/de/mannheim/th/chess/ui/ModeSelectionFrame.java

@@ -28,7 +28,7 @@ public class ModeSelectionFrame extends JFrame {
   private final ArrayList<Game> spiele = new ArrayList<>();
   private String fen;
 
-    public ModeSelectionFrame() {
+  public ModeSelectionFrame(MainFrame mf) {
     // Frame-Eigenschaften
     setTitle("Modusauswahl");
     setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
@@ -121,8 +121,10 @@ public class ModeSelectionFrame extends JFrame {
         boolean zuruecknahme = jb2.isSelected();
 
         Game game = new Game(modus, rotieren, zuruecknahme, fen);
+        mf.setGame(game);
+        mf.startGame();
 
-                spiele.add(game);
+        // spiele.add(game);
 
         dispose();
       }

src/main/java/de/mannheim/th/chess/ui/PGNLoaderFrame.java

@@ -0,0 +1,156 @@
+package de.mannheim.th.chess.ui;
+
+import java.util.List;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.io.File;
+
+import javax.swing.BoxLayout;
+import javax.swing.DefaultListModel;
+import javax.swing.JButton;
+import javax.swing.JFileChooser;
+import javax.swing.JFrame;
+import javax.swing.JList;
+import javax.swing.JPanel;
+import javax.swing.JProgressBar;
+import javax.swing.JScrollPane;
+import javax.swing.ListSelectionModel;
+import javax.swing.SwingWorker;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import com.github.bhlangonijr.chesslib.game.Game;
+import com.github.bhlangonijr.chesslib.pgn.PgnHolder;
+import com.github.bhlangonijr.chesslib.pgn.PgnLoadListener;
+
+public class PGNLoaderFrame extends JFrame {
+
+  private static final Logger logger = LogManager.getLogger(PGNLoaderFrame.class);
+
+  private PgnHolder pgn;
+  private File selectedFile;
+  private List<Game> games;
+  private DefaultListModel<String> gameListModel;
+  private JPanel contentPane;
+  private JList<String> gameList;
+  private JProgressBar progressBar;
+
+  /**
+   * Opens the PNGLoaderFrame
+   */
+  public PGNLoaderFrame(MainFrame mf) {
+
+    // ----- Style -----
+    setResizable(true);
+    setAlwaysOnTop(true);
+    setTitle("PGNLoader");
+    setBounds(100, 100, 500, 500);
+
+    // ----- contentPane -----
+    contentPane = new JPanel();
+    contentPane.setLayout(new BoxLayout(contentPane, BoxLayout.Y_AXIS));
+
+    setContentPane(contentPane);
+
+    // ----- FileSelector -----
+    JButton fileSelectButton = new JButton("Select File");
+    fileSelectButton.addActionListener(e -> {
+      JFileChooser fileChooser = new JFileChooser();
+      int returnValue = fileChooser.showOpenDialog(null);
+      if (returnValue == JFileChooser.APPROVE_OPTION) {
+        selectedFile = fileChooser.getSelectedFile();
+      }
+    });
+    contentPane.add(fileSelectButton);
+
+    // ----- LoadButton -----
+    JButton loadPgnButton = new JButton("Load file");
+    loadPgnButton.addActionListener(e -> loadFile());
+    contentPane.add(loadPgnButton);
+
+    // ----- SelectionList -----
+    gameListModel = new DefaultListModel<>();
+    gameList = new JList<>(gameListModel);
+    gameList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+    gameList.setVisibleRowCount(5);
+    JScrollPane scrollPane = new JScrollPane(gameList);
+    contentPane.add(scrollPane);
+
+    // ----- ProgressBar -----
+    progressBar = new JProgressBar(0, 100);
+    progressBar.setValue(0);
+    progressBar.setStringPainted(true);
+    contentPane.add(progressBar);
+
+    // ----- StartButton -----
+    JButton startGameButton = new JButton("Starte Spiel");
+    startGameButton.addActionListener(e -> {
+      int index = gameList.getSelectedIndex();
+      de.mannheim.th.chess.domain.Game game = new de.mannheim.th.chess.domain.Game(games.get(index).getHalfMoves());
+
+      mf.setGame(game);
+      mf.startView();
+    });
+    contentPane.add(startGameButton);
+
+    this.setVisible(true);
+
+  }
+
+  private void loadFile() {
+    if (this.selectedFile != null) {
+      pgn = new PgnHolder(this.selectedFile.getAbsolutePath());
+
+      LoadPGNWorker loadPGNWorker = new LoadPGNWorker();
+      loadPGNWorker.addPropertyChangeListener(e -> {
+        progressBar.setIndeterminate(true);
+      });
+
+      pgn.getListener().add(loadPGNWorker);
+      loadPGNWorker.execute();
+
+      gameList.revalidate();
+    }
+  }
+
+  private class LoadPGNWorker extends SwingWorker<Integer, Integer> implements PgnLoadListener {
+
+    @Override
+    protected Integer doInBackground() throws Exception {
+      try {
+        pgn.loadPgn();
+        games = pgn.getGames();
+        int totalGames = games.size();
+        for (int i = 0; i < totalGames; i++) {
+          publish(i);
+        }
+      } catch (Exception e) {
+        logger.info("Could not load pgn file!");
+      }
+      return pgn.getSize();
+    }
+
+    @Override
+    protected void process(List<Integer> chunks) {
+      for (Integer index : chunks) {
+        gameListModel.addElement("Game: " + index);
+        setProgress(Math.min(90, index * 100 / games.size()));
+      }
+    }
+
+    @Override
+    protected void done() {
+      setProgress(100);
+      progressBar.setValue(100);
+      progressBar.setIndeterminate(false);
+    }
+
+    @Override
+    public void notifyProgress(int games) {
+      setProgress(Math.min(90, games));
+      progressBar.setValue(Math.min(90, games));
+    }
+  }
+
+}

src/main/java/de/mannheim/th/chess/ui/SpielFrame.java

@@ -14,9 +14,15 @@ import de.mannheim.th.chess.utl.Clock;
 import de.mannheim.th.chess.controller.ButtonAufgebenListener;
 import de.mannheim.th.chess.controller.ButtonFileSaverListener;
 import de.mannheim.th.chess.controller.ButtonMovePieceListener;
+import de.mannheim.th.chess.controller.controlPanel.ButtonQuickloadListener;
+import de.mannheim.th.chess.controller.controlPanel.ButtonQuicksaveListener;
 import de.mannheim.th.chess.controller.ButtonSelectPieceListener;
 import de.mannheim.th.chess.controller.ButtonToNormalListener;
 import de.mannheim.th.chess.controller.ButtonUndoMoveListener;
+import de.mannheim.th.chess.controller.controlPanel.ButtonViewBackListener;
+import de.mannheim.th.chess.controller.controlPanel.ButtonViewFirstListener;
+import de.mannheim.th.chess.controller.controlPanel.ButtonViewForwardListener;
+import de.mannheim.th.chess.controller.controlPanel.ButtonViewLastListener;
 
 import java.awt.Font;
 
@@ -36,7 +42,8 @@ import javax.swing.JTextArea;
 import java.awt.BorderLayout;
 import java.awt.Color;
 import java.awt.Component;
-
+import java.awt.Dimension;
+import java.awt.FlowLayout;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -49,7 +56,7 @@ public class SpielFrame extends JFrame {
   private static final long serialVersionUID = 1L;
   private ArrayList<JButton> buttons = new ArrayList<>();
   private HashMap<JButton, String> belegungen = new HashMap<>();
-	private JPanel panelLinks, panelRechts, contentPane;
+  private JPanel panelLinks, panelRechts, contentPane, controlPanel;
   private JButton undo, undo2;
   private JTextArea ausgabe;
   private Game game;
@@ -96,6 +103,8 @@ public class SpielFrame extends JFrame {
     // Panel für alle Eingaben von Player 2
     panelRechts.add(getUiPlayerTwo());
 
+    panelRechts.add(createControlPanel());
+
     // Panel für Statistikanzeigen
     panelRechts.add(getUiStatistik());
 
@@ -119,14 +128,11 @@ public class SpielFrame extends JFrame {
    */
   public void erstelleBrett() {
 
-		this.clearButtons();
-		this.setDefaultBackground();
+    this.setDefaultButtons();
     this.setButtonsActions();
+    this.applyBoardButtons();
 
-		ladeBrett();
-
-		panelLinks.revalidate();
-		panelLinks.repaint();
+    this.ladeBrett();
 
   }
 
@@ -137,7 +143,7 @@ public class SpielFrame extends JFrame {
   /**
    * holt sich FEN-Zeichenkette und extrahiert daraus die Positionen der Figuren
    */
-	private void ladeBrett() {
+  public void ladeBrett() {
     // System.out.println(game.toFEN());
 
     char[] fen = game.toFEN().replaceAll("/", "").split(" ")[0].toCharArray();
@@ -165,6 +171,10 @@ public class SpielFrame extends JFrame {
       i++;
 
     }
+
+    panelLinks.revalidate();
+    panelLinks.repaint();
+
   }
 
   /**
@@ -208,6 +218,14 @@ public class SpielFrame extends JFrame {
     }
   }
 
+  /**
+   * Sets the to default buttons
+   */
+  public void setDefaultButtons() {
+    this.clearButtons();
+    this.setDefaultBackground();
+  }
+
   /*
    * Switches the button actions depending on the boardmode
    */
@@ -247,16 +265,14 @@ public class SpielFrame extends JFrame {
         }
         break;
       case finished:
-			clearButtons();
+        // this.enableControlPanelButtons();
+        // this.viewPointer = this.game.getMoveList().size() - 1;
         break;
       default:
         break;
 
     }
 
-		for (JButton b : buttons) {
-			panelLinks.add(b);
-		}
   }
 
   public void showDraw() {
@@ -313,6 +329,55 @@ public class SpielFrame extends JFrame {
     return result[0];
   }
 
+  /**
+   * Creates the controlPanel and its Buttons
+   */
+  private JPanel createControlPanel() {
+    this.controlPanel = new JPanel();
+    this.controlPanel.setBackground(new Color(90, 90, 90));
+    this.controlPanel.setLayout(new FlowLayout());
+
+    this.controlPanel.setMaximumSize(new Dimension(Integer.MAX_VALUE, controlPanel.getPreferredSize().height));
+
+    // ----- ViewQuicksaveButton -----
+    JButton quicksave = new JButton("Quicksave");
+    quicksave.setEnabled(true);
+    quicksave.addActionListener(new ButtonQuicksaveListener(this.game));
+    this.controlPanel.add(quicksave);
+
+    // ----- ViewFirstButton -----
+    JButton viewFirstButton = new JButton("<<-");
+    viewFirstButton.setEnabled(false);
+    viewFirstButton.addActionListener(new ButtonViewFirstListener(this.game, this));
+    this.controlPanel.add(viewFirstButton);
+
+    // ----- ViewBackButton -----
+    JButton viewBackButton = new JButton("<-");
+    viewBackButton.setEnabled(false);
+    viewBackButton.addActionListener(new ButtonViewBackListener(this.game, this));
+    this.controlPanel.add(viewBackButton);
+
+    // ----- ViewForwardButton -----
+    JButton viewForwardButton = new JButton("->");
+    viewForwardButton.setEnabled(false);
+    viewForwardButton.addActionListener(new ButtonViewForwardListener(this.game, this));
+    this.controlPanel.add(viewForwardButton);
+
+    // ----- ViewLastButton -----
+    JButton viewLastButton = new JButton("->>");
+    viewLastButton.setEnabled(false);
+    viewLastButton.addActionListener(new ButtonViewLastListener(this.game, this));
+    this.controlPanel.add(viewLastButton);
+
+    // ----- ViewQuickloadButton -----
+    JButton quickload = new JButton("Quickload");
+    quickload.setEnabled(true);
+    quickload.addActionListener(new ButtonQuickloadListener(this.game, this));
+    this.controlPanel.add(quickload);
+
+    return controlPanel;
+  }
+
   private JPanel getUiPlayerTwo() {
 
     JPanel playerTwo = new JPanel();
@@ -532,4 +597,28 @@ public class SpielFrame extends JFrame {
     return clock;
   }
 
+  public void setMode(BoardMode mode) {
+    this.mode = mode;
+  }
+
+  /**
+   * Inverts the Enabled property of the controlpanelButtons
+   */
+  public void enableControlPanelButtons() {
+    for (Component c : this.controlPanel.getComponents()) {
+      if (c instanceof JButton) {
+        c.setEnabled(!c.isEnabled());
+      }
+    }
+  }
+
+  /**
+   * Adds the buttons to the boardpanel
+   */
+  public void applyBoardButtons() {
+    for (JButton b : buttons) {
+      panelLinks.add(b);
+    }
+  }
+
 }