MenuBar.java

package ui.menubar;

import javafx.application.Platform;
import javafx.beans.property.BooleanProperty;
import javafx.beans.property.SimpleBooleanProperty;
import javafx.collections.ListChangeListener;
import javafx.collections.ObservableList;
import javafx.embed.swing.SwingFXUtils;
import javafx.fxml.FXML;
import javafx.scene.Node;
import javafx.scene.control.*;
import javafx.scene.control.Alert.AlertType;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.control.MenuItem;
import javafx.scene.image.Image;
import javafx.stage.FileChooser;
import javafx.stage.FileChooser.ExtensionFilter;
import javafx.stage.Stage;
import libsidplay.C64;
import libsidplay.common.Event;
import libsidplay.common.EventScheduler;
import libsidplay.common.Mixer;
import libsidplay.components.c1530.Datasette;
import libsidplay.components.c1541.ExtendImagePolicy;
import libsidplay.components.c1541.FloppyType;
import libsidplay.components.cart.CartridgeType;
import libsidplay.components.printer.PrinterConnection;
import libsidplay.components.printer.PrinterModel;
import libsidplay.sidtune.SidTune;
import libsidplay.sidtune.SidTuneError;
import libsidplay.sidtune.SidTuneInfo;
import libsidutils.IOUtils;
import sidplay.Player;
import sidplay.player.PlayList;
import sidplay.player.State;
import ui.JSidPlay2Main;
import ui.about.About;
import ui.asm.Asm;
import ui.assembly64.Assembly64;
import ui.audiosettings.AudioSettings;
import ui.common.C64VBox;
import ui.common.C64Window;
import ui.common.Toast;
import ui.common.UIPart;
import ui.common.fileextension.CartFileExtensions;
import ui.common.fileextension.DiskFileExtensions;
import ui.common.fileextension.TapeFileExtensions;
import ui.common.fileextension.TuneFileExtensions;
import ui.common.util.DesktopUtil;
import ui.console.Console;
import ui.disassembler.Disassembler;
import ui.diskcollection.DiskCollectionType;
import ui.emulationsettings.EmulationSettings;
import ui.entities.config.*;
import ui.favorites.Favorites;
import ui.favorites.PlaybackType;
import ui.gamebase.GameBase;
import ui.joysticksettings.JoystickSettings;
import ui.musiccollection.MusicCollectionType;
import ui.oscilloscope.Oscilloscope;
import ui.printer.Printer;
import ui.proxysettings.ProxySettings;
import ui.siddump.SidDump;
import ui.sidreg.SidReg;
import ui.ultimate64.Ultimate64Window;
import ui.update.Update;
import ui.vic.VICExplorer;
import ui.videoplayer.VideoPlayer;
import ui.videoscreen.Video;
import ui.webview.WebViewType;
import ui.whatssidsettings.WhatsSidSettings;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.*;
import java.net.URL;
import java.util.Arrays;
import java.util.Iterator;

import static java.util.Objects.requireNonNull;
import static libsidplay.sidtune.SidTune.RESET;
import static ui.common.properties.BindingUtils.bindBidirectional;

public class MenuBar extends C64VBox implements UIPart {
    /**
     * NUVIE video player
     */
    private static final String NUVIE_PLAYER_PRG = "/libsidplay/roms/nuvieplayer-v1.0.prg";
    private static final byte[] NUVIE_PLAYER;
    /**
     * Empty disk image
     */
    private static final String EMPTY_D64 = "/libsidplay/components/c1541/empty.d64";
    private static final byte[] EMPTY_DISK;

    private static final String ACTION_REPLAY_MKVI = "/libsidplay/components/cart/AR_60PAL.CRT";

    static {
        try (DataInputStream is2 = new DataInputStream(requireNonNull(MenuBar.class.getResourceAsStream(EMPTY_D64)));
             DataInputStream is = new DataInputStream(requireNonNull(MenuBar.class.getResourceAsStream(NUVIE_PLAYER_PRG)))) {
            URL us3 = JSidPlay2Main.class.getResource(EMPTY_D64);
            EMPTY_DISK = new byte[requireNonNull(us3).openConnection().getContentLength()];
            is2.readFully(EMPTY_DISK);
            URL us2 = JSidPlay2Main.class.getResource(NUVIE_PLAYER_PRG);
            NUVIE_PLAYER = new byte[requireNonNull(us2).openConnection().getContentLength()];
            is.readFully(NUVIE_PLAYER);
        } catch (IOException e) {
            throw new ExceptionInInitializerError(e);
        }
    }

    @FXML
    protected CheckMenuItem pauseContinue, playListStartsWithOne, turboTape, driveOn, driveSoundOn, parCable,
            installJiffyDos, expand2000, expand4000, expand6000, expand8000, expandA000, turnPrinterOn, warp, warpOnStartup;

    @FXML
    protected RadioMenuItem fastForward, normalSpeed;

    @FXML
    protected MenuItem previousSong, nextSong, stop, video, oscilloscope, vicExplorer, favorites, hvsc, cgsc, hvmec, demos, mags,
            sidDump, sidRegisters, asm, disassembler, assembly64, csdb, remixKwedOrg, lemon64, forum64, soasc,
            codebase64, gamebase, jsidplay2Src, printer, console, jsidplay2userGuide, jsidplay2Javadoc, videoPlayer,
            saveTune;

    @FXML
    protected Button btnPlay, btnPause, btnPreviousSong, btnNextSong, btnNextFavorite, btnStop;

    @FXML
    private ToggleGroup floppyGroup, extensionGroup, printerModelGroup, printerConnectionGroup;

    @FXML
    private ToggleButton btnFastForward, btnMinimizeMaximize;

    @FXML
    protected Tooltip btnPreviousSongToolTip, btnNextSongToolTip;

    @FXML
    protected Label tracks, whatssidPositioner, warpStatus, inspectionIndicator;

    private class StateChangeListener implements PropertyChangeListener {
        @Override
        public void propertyChange(PropertyChangeEvent event) {
            Platform.runLater(() -> {
                if (event.getNewValue() == State.START) {
                    setCurrentTrack(util.getPlayer().getTune());
                }
                updatePlayerButtons((State) event.getNewValue(),
                        util.getPlayer().getMixerInfo(Mixer::isFastForward, false));
            });
        }

    }

    private BooleanProperty btnNextFavoriteDisabledState, btnNextSongDisabledState;
    private int hardcopyCounter;
    private StateChangeListener propertyChangeListener;
    private PropertyChangeListener warpListener;
    private PropertyChangeListener inspectionListener;

    public MenuBar() {
        super();
    }

    public MenuBar(C64Window window, Player player) {
        super(window, player);
    }

    @FXML
    @Override
    protected void initialize() {
        final Configuration config = util.getConfig();
        final SidPlay2Section sidplay2Section = config.getSidplay2Section();
        final C1541Section c1541Section = config.getC1541Section();
        final PrinterSection printer = config.getPrinterSection();

        btnFastForward.selectedProperty().bindBidirectional(fastForward.selectedProperty());
        btnNextFavoriteDisabledState = new SimpleBooleanProperty(true);
        btnNextFavorite.disableProperty().bind(btnNextFavoriteDisabledState);
        btnNextSongDisabledState = new SimpleBooleanProperty(true);
        playListStartsWithOne.selectedProperty().bindBidirectional(sidplay2Section.playListStartsWithOneProperty());

        warpOnStartup.selectedProperty().bindBidirectional(sidplay2Section.warpOnStartupProperty());
        warpStatus.managedProperty().bind(warpStatus.visibleProperty());
        // FXML initialization runs from the superclass constructor, before field initializers.
        warpListener = event -> Platform.runLater(this::updateWarpControls);
        util.getPlayer().warpProperty().addListener(warpListener);
        inspectionListener = event -> Platform.runLater(() -> {
            String status = (String) event.getNewValue();
            boolean indicated = status.equals("ARMED") || status.equals("PAUSED") || status.equals("RECORDING");
            inspectionIndicator.setText(util.getBundle().getString("INSPECTION_" + status));
            inspectionIndicator.setVisible(indicated);
            inspectionIndicator.setManaged(indicated);
        });
        util.getPlayer().inspectionStatusProperty().addListener(inspectionListener);
        turboTape.selectedProperty().bindBidirectional(sidplay2Section.turboTapeProperty());
        driveOn.selectedProperty().bindBidirectional(c1541Section.driveOnProperty());
        parCable.selectedProperty().bindBidirectional(c1541Section.parallelCableProperty());
        installJiffyDos.selectedProperty().bindBidirectional(c1541Section.jiffyDosInstalledProperty());
        driveSoundOn.selectedProperty().bindBidirectional(c1541Section.driveSoundOnProperty());
        turnPrinterOn.selectedProperty().bindBidirectional(printer.printerOnProperty());
        bindBidirectional(printerModelGroup, printer.printerModelProperty(), PrinterModel.class);
        bindBidirectional(printerConnectionGroup, printer.printerConnectionProperty(), PrinterConnection.class);

        bindBidirectional(floppyGroup, c1541Section.floppyTypeProperty(), FloppyType.class);

        bindBidirectional(extensionGroup, c1541Section.extendImagePolicyProperty(), ExtendImagePolicy.class);

        expand2000.selectedProperty().bindBidirectional(c1541Section.ramExpansionEnabled0Property());
        expand4000.selectedProperty().bindBidirectional(c1541Section.ramExpansionEnabled1Property());
        expand6000.selectedProperty().bindBidirectional(c1541Section.ramExpansionEnabled2Property());
        expand8000.selectedProperty().bindBidirectional(c1541Section.ramExpansionEnabled3Property());
        expandA000.selectedProperty().bindBidirectional(c1541Section.ramExpansionEnabled4Property());
        var non1541 = javafx.beans.binding.Bindings.createBooleanBinding(() ->
                        c1541Section.getFloppyType() != FloppyType.C1541
                                && c1541Section.getFloppyType() != FloppyType.C1541_II,
                c1541Section.floppyTypeProperty());
        for (var option : new CheckMenuItem[]{parCable, expand2000, expand4000,
                expand6000, expand8000, expandA000}) {
            option.disableProperty().bind(non1541);
        }

        // the preview view does not provide a window
        if (util.getWindow() != null) {
            Stage stage = util.getWindow().getStage();
            stage.maximizedProperty()
                    .addListener((observable, oldValue, newValue) -> btnMinimizeMaximize.setDisable(newValue));
            btnMinimizeMaximize.selectedProperty().bindBidirectional(sidplay2Section.minimizedProperty());
            btnMinimizeMaximize.selectedProperty().addListener((observable, oldValue, newValue) -> {
                hideMainTabbedPane(stage, newValue);
                if (newValue) {
                    sidplay2Section.setMinimizedX(getScene().getWindow().getX());
                    sidplay2Section.setMinimizedY(getScene().getWindow().getY());
                    sidplay2Section.setMinimizedWidth(getScene().getWindow().getWidth());
                    sidplay2Section.setMinimizedHeight(getScene().getWindow().getHeight());
                    resizeToMinHeight(stage);
                } else {
                    getScene().getWindow().setX(sidplay2Section.getMinimizedX());
                    getScene().getWindow().setY(sidplay2Section.getMinimizedY());
                    getScene().getWindow().setWidth(sidplay2Section.getMinimizedWidth());
                    getScene().getWindow().setHeight(sidplay2Section.getMinimizedHeight());
                }
            });
            if (sidplay2Section.isMinimized()) {
                Platform.runLater(() -> {
                    hideMainTabbedPane(stage, true);
                    resizeToMinHeight(stage);
                });
            }
        }

        ((ObservableList<ViewEntity>) util.getConfig().getViews())
                .addListener((ListChangeListener<ViewEntity>) c -> updateMenuItems());
        updateMenuItems();

        updatePlayerButtons(util.getPlayer().stateProperty().get(),
                util.getPlayer().getMixerInfo(Mixer::isFastForward, false));

        propertyChangeListener = new StateChangeListener();
        util.getPlayer().stateProperty().addListener(propertyChangeListener);

        util.getPlayer().setWhatsSidHook(musicInfoWithConfidence -> Platform.runLater(() -> {
            System.out.println(musicInfoWithConfidence);
            Toast.makeText("whatssid", whatssidPositioner, musicInfoWithConfidence.toString(), 5);
        }));
    }

    @Override
    public void doClose() {
        util.getPlayer().stateProperty().removeListener(propertyChangeListener);
        util.getPlayer().warpProperty().removeListener(warpListener);
        util.getPlayer().inspectionStatusProperty().removeListener(inspectionListener);
    }

    private void updateMenuItems() {
        for (MenuItem menuItem : Arrays.asList(video, oscilloscope, vicExplorer, favorites, hvsc, cgsc, hvmec, demos, mags, sidDump,
                sidRegisters, asm, disassembler, assembly64, csdb, remixKwedOrg, lemon64, forum64, soasc, codebase64,
                gamebase, jsidplay2Src, printer, console, jsidplay2userGuide, jsidplay2Javadoc, videoPlayer)) {
            menuItem.setDisable(false);
        }
        util.getConfig().getViews().stream().map(ViewEntity::getFxId).forEach(fxId -> {
            if (Video.ID.equals(fxId)) {
                video.setDisable(true);
            } else if (Oscilloscope.ID.equals(fxId)) {
                oscilloscope.setDisable(true);
            } else if (VICExplorer.ID.equals(fxId)) {
                vicExplorer.setDisable(true);
            } else if (Favorites.ID.equals(fxId)) {
                favorites.setDisable(true);
            } else if (MusicCollectionType.HVSC.name().equals(fxId)) {
                hvsc.setDisable(true);
            } else if (MusicCollectionType.CGSC.name().equals(fxId)) {
                cgsc.setDisable(true);
            } else if (DiskCollectionType.HVMEC.name().equals(fxId)) {
                hvmec.setDisable(true);
            } else if (DiskCollectionType.DEMOS.name().equals(fxId)) {
                demos.setDisable(true);
            } else if (DiskCollectionType.MAGS.name().equals(fxId)) {
                mags.setDisable(true);
            } else if (SidDump.ID.equals(fxId)) {
                sidDump.setDisable(true);
            } else if (SidReg.ID.equals(fxId)) {
                sidRegisters.setDisable(true);
            } else if (Asm.ID.equals(fxId)) {
                asm.setDisable(true);
            } else if (Disassembler.ID.equals(fxId)) {
                disassembler.setDisable(true);
            } else if (Assembly64.ID.equals(fxId)) {
                assembly64.setDisable(true);
            } else if (WebViewType.CSDB.name().equals(fxId)) {
                csdb.setDisable(true);
            } else if (WebViewType.REMIX_KWED_ORG.name().equals(fxId)) {
                remixKwedOrg.setDisable(true);
            } else if (WebViewType.LEMON64_COM.name().equals(fxId)) {
                lemon64.setDisable(true);
            } else if (WebViewType.FORUM64_DE.name().equals(fxId)) {
                forum64.setDisable(true);
            } else if (WebViewType.SOASC.name().equals(fxId)) {
                soasc.setDisable(true);
            } else if (WebViewType.CODEBASE64.name().equals(fxId)) {
                codebase64.setDisable(true);
            } else if (GameBase.ID.equals(fxId)) {
                gamebase.setDisable(true);
            } else if (WebViewType.JSIDPLAY2_SRC.name().equals(fxId)) {
                jsidplay2Src.setDisable(true);
            } else if (Printer.ID.equals(fxId)) {
                printer.setDisable(true);
            } else if (Console.ID.equals(fxId)) {
                console.setDisable(true);
            } else if (WebViewType.USERGUIDE.name().equals(fxId)) {
                jsidplay2userGuide.setDisable(true);
            } else if (WebViewType.JSIDPLAY2_JAVADOC.name().equals(fxId)) {
                jsidplay2Javadoc.setDisable(true);
            } else if (VideoPlayer.ID.equals(fxId)) {
                videoPlayer.setDisable(true);
            } else {
                throw new RuntimeException("Unknown view ID: " + fxId);
            }
        });
    }

    private void hideMainTabbedPane(Stage stage, Boolean hide) {
        Node node = getScene().lookup("#tabbedPane");
        node.setVisible(!hide);
        node.setManaged(!hide);
        stage.setResizable(!hide);
    }

    private void resizeToMinHeight(Stage stage) {
        stage.sizeToScene();
        // For Mac OS X:
        Platform.runLater(() -> btnMinimizeMaximize.setDisable(false));
    }

    @FXML
    private void load() {
        final FileChooser fileDialog = new FileChooser();
        fileDialog.setInitialDirectory(util.getConfig().getSidplay2Section().getLastDirectory());
        fileDialog.getExtensionFilters()
                .add(new ExtensionFilter(TuneFileExtensions.DESCRIPTION, TuneFileExtensions.EXTENSIONS));
        final File file = fileDialog.showOpenDialog(getScene().getWindow());
        if (file != null) {
            util.getConfig().getSidplay2Section().setLastDirectory(file.getParentFile());
            try {
                util.getPlayer().play(SidTune.load(file));
            } catch (IOException | SidTuneError e) {
                openErrorDialog(String.format(util.getBundle().getString("ERR_IO_ERROR"), e.getMessage()));
            }
        }
    }

    @FXML
    private void saveTune() {
        final FileChooser fileDialog = new FileChooser();
        fileDialog.setInitialDirectory(util.getConfig().getSidplay2Section().getLastDirectory());
        fileDialog.getExtensionFilters()
                .add(new ExtensionFilter(TuneFileExtensions.DESCRIPTION, TuneFileExtensions.EXTENSIONS));
        final File file = fileDialog.showSaveDialog(getScene().getWindow());
        if (file != null) {
            util.getConfig().getSidplay2Section().setLastDirectory(file.getParentFile());
            try {
                util.getPlayer().getTune().save(file.getAbsolutePath());
            } catch (IOException e) {
                openErrorDialog(String.format(util.getBundle().getString("ERR_IO_ERROR"), e.getMessage()));
            }
        }
    }

    @FXML
    private void playVideo() {
        final FileChooser fileDialog = new FileChooser();
        fileDialog.setInitialDirectory(util.getConfig().getSidplay2Section().getLastDirectory());
        fileDialog.getExtensionFilters()
                .add(new ExtensionFilter(CartFileExtensions.DESCRIPTION, CartFileExtensions.EXTENSIONS));
        final File file = fileDialog.showOpenDialog(getScene().getWindow());
        if (file != null) {
            try (InputStream is = new ByteArrayInputStream(NUVIE_PLAYER)) {
                util.getPlayer().insertCartridge(CartridgeType.REU, file);
                util.getPlayer().play(SidTune.load("nuvieplayer-v1.0.prg", is));
            } catch (IOException | SidTuneError e) {
                openErrorDialog(String.format(util.getBundle().getString("ERR_IO_ERROR"), e.getMessage()));
            }
        }
    }

    @FXML
    private void reset() {
        util.getPlayer().play(RESET);
    }

    @FXML
    private void quit() {
        util.getWindow().close();
    }

    @FXML
    private void pauseContinue() {
        util.getPlayer().pauseContinue();
    }

    @FXML
    private void previousSong() {
        util.getPlayer().previousSong();
    }

    @FXML
    private void nextSong() {
        util.getPlayer().nextSong();
    }

    @FXML
    private void warp() {
        util.getPlayer().setWarp(warp.isSelected());
    }

    @FXML
    private void warpStartupTimeout() {
        SidPlay2Section section = util.getConfig().getSidplay2Section();
        TextInputDialog dialog = new TextInputDialog(Integer.toString(section.getWarpStartupTimeout()));
        dialog.setTitle(util.getBundle().getString("WARP_STARTUP_TIMEOUT"));
        dialog.setHeaderText(util.getBundle().getString("WARP_STARTUP_TIMEOUT_PROMPT"));
        dialog.showAndWait().ifPresent(value -> {
            try {
                section.setWarpStartupTimeout(Integer.parseInt(value.trim()));
            } catch (IllegalArgumentException e) {
                openErrorDialog(util.getBundle().getString("WARP_STARTUP_TIMEOUT_PROMPT"));
            }
        });
    }

    @FXML
    private void normalSpeed() {
        util.getPlayer().configureMixer(Mixer::normalSpeed);
    }

    @FXML
    private void fastForward() {
        util.getPlayer().configureMixer(Mixer::fastForward);
    }

    @FXML
    private void fastForward2X() {
        Boolean isFastForward = util.getPlayer().getMixerInfo(Mixer::isFastForward, false);
        if (isFastForward) {
            util.getPlayer().configureMixer(Mixer::normalSpeed);
        } else {
            util.getPlayer().configureMixer(Mixer::fastForward);
        }
        updatePlayerButtons(util.getPlayer().stateProperty().get(), !isFastForward);
    }

    @FXML
    private void nextFavorite() {
        final C64 c64 = util.getPlayer().getC64();
        final EventScheduler ctx = c64.getEventScheduler();
        ctx.scheduleThreadSafe(Event.of("Timer End To Play Next Favorite!", event -> {
            if (util.getPlayer().stateProperty().get() == State.PLAY
                    || util.getPlayer().stateProperty().get() == State.PAUSE) {
                util.getPlayer().getPlayList().last();
                util.getPlayer().getTimer().end();
            }
        }));
    }

    @FXML
    private void stop() {
        util.getPlayer().quit();
    }

    @FXML
    private void playListStartsWithOne() {
        final SidPlay2Section sidplay2Section = util.getConfig().getSidplay2Section();

        util.getPlayer().setFirstPlayListEntryIsOne(sidplay2Section.isPlayListStartsWithOne());
    }

    @FXML
    private void doHardcopyGif() {
        createHardCopy("gif");
    }

    @FXML
    private void doHardcopyJpg() {
        createHardCopy("jpg");
    }

    @FXML
    private void doHardcopyPng() {
        createHardCopy("png");
    }

    @FXML
    private void ultimate64() {
        new Ultimate64Window(util.getPlayer()).open();
    }

    @FXML
    private void audioSettings() {
        new AudioSettings(util.getPlayer()).open();
    }

    @FXML
    private void emulationSettings() {
        new EmulationSettings(util.getPlayer()).open();
    }

    @FXML
    private void whatsSidSettings() {
        new WhatsSidSettings(util.getPlayer()).open();
    }

    @FXML
    private void joystickSettings() {
        new JoystickSettings(util.getPlayer()).open();
    }

    @FXML
    private void proxySettings() {
        new ProxySettings(util.getPlayer()).open();
    }

    @FXML
    private void recordTape() {
        util.getPlayer().getDatasette().control(Datasette.Control.RECORD);
    }

    @FXML
    private void playTape() {
        util.getPlayer().getDatasette().control(Datasette.Control.START);
    }

    @FXML
    private void rewindTape() {
        util.getPlayer().getDatasette().control(Datasette.Control.REWIND);
    }

    @FXML
    private void forwardTape() {
        util.getPlayer().getDatasette().control(Datasette.Control.FORWARD);
    }

    @FXML
    private void stopTape() {
        util.getPlayer().getDatasette().control(Datasette.Control.STOP);
    }

    @FXML
    private void resetCounter() {
        util.getPlayer().getDatasette().control(Datasette.Control.RESET_COUNTER);
    }

    @FXML
    private void insertTape() {
        final FileChooser fileDialog = new FileChooser();
        fileDialog.setInitialDirectory(util.getConfig().getSidplay2Section().getLastDirectory());
        fileDialog.getExtensionFilters()
                .add(new ExtensionFilter(TapeFileExtensions.DESCRIPTION, TapeFileExtensions.EXTENSIONS));
        fileDialog.setTitle(util.getBundle().getString("INSERT_TAPE"));
        final File file = fileDialog.showOpenDialog(getScene().getWindow());
        if (file != null) {
            try {
                util.getPlayer().insertTape(file);
            } catch (IOException | SidTuneError e) {
                System.err.printf("Cannot insert media file '%s'.%n", file.getAbsolutePath());
            }
        }
    }

    @FXML
    private void ejectTape() {
        try {
            util.getPlayer().getDatasette().ejectTape();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @FXML
    private void turnDriveOn() {
        util.getPlayer().enableFloppyDiskDrives(util.getConfig().getC1541Section().isDriveOn());
    }

    @FXML
    private void parallelCable() {
        util.getPlayer().connectC64AndC1541WithParallelCable(util.getConfig().getC1541Section().isParallelCable());
    }

    @FXML
    private void installJiffyDos() {
        reset();
    }

    /**
     * Select the drive model and restore the displayed selection if the media is incompatible.
     *
     * @param type requested floppy model
     */
    private void selectFloppy(FloppyType type) {
        try {
            util.getPlayer().setFloppyType(type);
        } catch (IOException e) {
            util.getConfig().getC1541Section().setFloppyType(util.getPlayer().getFloppyType());
            System.err.println(e.getMessage());
        }
    }

    @FXML
    private void floppyTypeC1571() {
        selectFloppy(FloppyType.C1571);
    }

    @FXML
    private void floppyTypeC1581() {
        selectFloppy(FloppyType.C1581);
    }

    @FXML
    private void floppyTypeC1541() {
        selectFloppy(FloppyType.C1541);
    }

    @FXML
    private void floppyTypeC1541_II() {
        selectFloppy(FloppyType.C1541_II);
    }

    @FXML
    private void extendNever() {
        util.getConfig().getC1541Section().setExtendImagePolicy(ExtendImagePolicy.EXTEND_NEVER);
    }

    @FXML
    private void extendAsk() {
        util.getConfig().getC1541Section().setExtendImagePolicy(ExtendImagePolicy.EXTEND_ASK);
    }

    @FXML
    private void extendAccess() {
        util.getConfig().getC1541Section().setExtendImagePolicy(ExtendImagePolicy.EXTEND_ACCESS);
    }

    @FXML
    private void expansion0x2000() {
        setRamExpansion(0, util.getConfig().getC1541Section().isRamExpansionEnabled0());
    }

    @FXML
    private void expansion0x4000() {
        setRamExpansion(1, util.getConfig().getC1541Section().isRamExpansionEnabled1());
    }

    @FXML
    private void expansion0x6000() {
        setRamExpansion(2, util.getConfig().getC1541Section().isRamExpansionEnabled2());
    }

    @FXML
    private void expansion0x8000() {
        setRamExpansion(3, util.getConfig().getC1541Section().isRamExpansionEnabled3());
    }

    @FXML
    private void expansion0xA000() {
        setRamExpansion(4, util.getConfig().getC1541Section().isRamExpansionEnabled4());
    }

    /**
     * Apply a RAM expansion change through the player's serialized drive operations.
     *
     * @param bank    expansion bank (0-4)
     * @param enabled true to enable the bank
     */
    private void setRamExpansion(int bank, boolean enabled) {
        try {
            util.getPlayer().setFloppyRamExpansion(bank, enabled);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @FXML
    private void insertDisk() {
        final FileChooser fileDialog = new FileChooser();
        fileDialog.setInitialDirectory(util.getConfig().getSidplay2Section().getLastDirectory());
        fileDialog.getExtensionFilters()
                .add(new ExtensionFilter(DiskFileExtensions.DESCRIPTION, DiskFileExtensions.EXTENSIONS));
        fileDialog.setTitle(util.getBundle().getString("INSERT_DISK"));
        final File file = fileDialog.showOpenDialog(getScene().getWindow());
        if (file != null) {
            try {
                util.getPlayer().insertDisk(file);
            } catch (IOException e) {
                System.err.printf("Cannot insert media file '%s'.%n", file.getAbsolutePath());
            }
        }
    }

    @FXML
    private void ejectDisk() {
        try {
            util.getPlayer().ejectDisk();
        } catch (IOException e1) {
            e1.printStackTrace();
        }
    }

    @FXML
    private void resetDrive() {
        try {
            util.getPlayer().resetFloppyDrive();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @FXML
    private void insertEmptyDisk() {
        final FileChooser fileDialog = new FileChooser();
        fileDialog.setInitialDirectory(util.getConfig().getSidplay2Section().getLastDirectory());
        fileDialog.getExtensionFilters()
                .add(new ExtensionFilter(DiskFileExtensions.DESCRIPTION, DiskFileExtensions.STD_EXTENSIONS()));
        fileDialog.setTitle(util.getBundle().getString("INSERT_EMPTY_DISK"));
        final File file = fileDialog.showSaveDialog(getScene().getWindow());
        if (file != null) {
            util.getConfig().getSidplay2Section().setLastDirectory(file.getParentFile());
            File target = new File(file.getParentFile(), IOUtils.getFilenameWithoutSuffix(file.getName()) + ".d64");
            try (DataOutputStream os = new DataOutputStream(new FileOutputStream(target))) {
                os.write(EMPTY_DISK);
            } catch (IOException e) {
                openErrorDialog(String.format(util.getBundle().getString("ERR_IO_WRITE_ERROR"), e.getMessage()));
            }
            video();
            try {
                util.getPlayer().insertDisk(target);
            } catch (IOException e) {
                System.err.printf("Cannot insert media file '%s'.%n", target.getAbsolutePath());
            }
        }
    }

    @FXML
    private void printerOn() {
        util.getPlayer().enablePrinter(util.getConfig().getPrinterSection().isPrinterOn());
    }

    @FXML
    private void insertCartridge() {
        chooseCartridge(CartridgeType.CRT);
    }

    @FXML
    private void insertGeoRAM() {
        chooseCartridge(CartridgeType.GEORAM);
    }

    @FXML
    private void insertGeoRAM64() {
        insertCartridge(CartridgeType.GEORAM, 64);
    }

    @FXML
    private void insertGeoRAM128() {
        insertCartridge(CartridgeType.GEORAM, 128);
    }

    @FXML
    private void insertGeoRAM256() {
        insertCartridge(CartridgeType.GEORAM, 256);
    }

    @FXML
    private void insertGeoRAM512() {
        insertCartridge(CartridgeType.GEORAM, 512);
    }

    @FXML
    private void insertGeoRAM1024() {
        insertCartridge(CartridgeType.GEORAM, 1024);
    }

    @FXML
    private void insertGeoRAM2048() {
        insertCartridge(CartridgeType.GEORAM, 2048);
    }

    @FXML
    private void insertGeoRAM4096() {
        insertCartridge(CartridgeType.GEORAM, 4096);
    }

    @FXML
    private void insertREU() {
        chooseCartridge(CartridgeType.REU);
    }

    @FXML
    private void insertREU128() {
        insertCartridge(CartridgeType.REU, 128);
    }

    @FXML
    private void insertREU256() {
        insertCartridge(CartridgeType.REU, 256);
    }

    @FXML
    private void insertREU512() {
        insertCartridge(CartridgeType.REU, 512);
    }

    @FXML
    private void insertREU2048() {
        insertCartridge(CartridgeType.REU, 2048);
    }

    @FXML
    private void insertREU16384() {
        insertCartridge(CartridgeType.REU, 16384);
    }

    @FXML
    private void insertARMKVI() {
        insertCartridge(MenuBar.class.getResourceAsStream(ACTION_REPLAY_MKVI));
    }

    @FXML
    private void insertSoundExpander3526() {
        insertCartridge(CartridgeType.SOUNDEXPANDER, 0);
        reset();
    }

    @FXML
    private void insertSoundExpander3812() {
        insertCartridge(CartridgeType.SOUNDEXPANDER, 1);
        reset();
    }

    @FXML
    private void ejectCartridge() {
        util.getPlayer().getC64().ejectCartridge();
        reset();
    }

    @FXML
    private void freezeCartridge() {
        util.getPlayer().getC64().getCartridge().freeze();
    }

    @FXML
    private void video() {
        addView(Video.ID);
    }

    @FXML
    private void oscilloscope() {
        addView(Oscilloscope.ID);
    }

    @FXML
    private void vicExplorer() {
        addView(VICExplorer.ID);
    }

    @FXML
    private void hvsc() {
        addView(MusicCollectionType.HVSC.name());
    }

    @FXML
    private void cgsc() {
        addView(MusicCollectionType.CGSC.name());
    }

    @FXML
    private void hvmec() {
        addView(DiskCollectionType.HVMEC.name());
    }

    @FXML
    private void demos() {
        addView(DiskCollectionType.DEMOS.name());
    }

    @FXML
    private void mags() {
        addView(DiskCollectionType.MAGS.name());
    }

    @FXML
    private void favorites() {
        addView(Favorites.ID);
    }

    @FXML
    private void gamebase() {
        addView(GameBase.ID);
    }

    @FXML
    private void asm() {
        addView(Asm.ID);
    }

    @FXML
    private void printer() {
        addView(Printer.ID);
    }

    @FXML
    private void console() {
        addView(Console.ID);
    }

    @FXML
    private void sidDump() {
        addView(SidDump.ID);
    }

    @FXML
    private void sidRegisters() {
        addView(SidReg.ID);
    }

    @FXML
    private void disassembler() {
        addView(Disassembler.ID);
    }

    @FXML
    private void assembly64() {
        addView(Assembly64.ID);
    }

    @FXML
    private void csdb() {
        addView(WebViewType.CSDB.name());
    }

    @FXML
    private void codebase64() {
        addView(WebViewType.CODEBASE64.name());
    }

    @FXML
    private void remixKweqOrg() {
        addView(WebViewType.REMIX_KWED_ORG.name());
    }

    @FXML
    private void forum64() {
        addView(WebViewType.FORUM64_DE.name());
    }

    @FXML
    private void lemon64() {
        addView(WebViewType.LEMON64_COM.name());
    }

    @FXML
    private void soasc() {
        addView(WebViewType.SOASC.name());
    }

    @FXML
    private void jsidplay2Src() {
        addView(WebViewType.JSIDPLAY2_SRC.name());
    }

    @FXML
    private void jsidplay2Javadoc() {
        addView(WebViewType.JSIDPLAY2_JAVADOC.name());
    }

    @FXML
    private void userguide() {
        addView(WebViewType.USERGUIDE.name());
    }

    @FXML
    private void videoPlayer() {
        addView(VideoPlayer.ID);
    }

    @FXML
    private void updateCheck() {
        new Update(util.getPlayer()).open();
    }

    @FXML
    private void about() {
        new About(util.getPlayer()).open();
    }

    private void addView(String fxId) {
        if (util.getConfig().getViews().stream().map(ViewEntity::getFxId).noneMatch(fxId::equals)) {
            util.getConfig().getViews().add(new ViewEntity(fxId));
        }
    }

    private void chooseCartridge(final CartridgeType type) {
        final FileChooser fileDialog = new FileChooser();
        fileDialog.setInitialDirectory(util.getConfig().getSidplay2Section().getLastDirectory());
        fileDialog.getExtensionFilters()
                .add(new ExtensionFilter(CartFileExtensions.DESCRIPTION, CartFileExtensions.EXTENSIONS));
        fileDialog.setTitle(util.getBundle().getString("INSERT_CARTRIDGE"));
        final File file = fileDialog.showOpenDialog(getScene().getWindow());
        if (file != null) {
            try {
                util.getPlayer().insertCartridge(type, file);
                util.getPlayer().play(RESET);
            } catch (IOException e) {
                System.err.printf("Cannot insert file '%s' as cartridge of type '%s'.%n",
                        file.getAbsolutePath(), type.name());
            }
        }
    }

    private void insertCartridge(CartridgeType type, int sizeKB) {
        try {
            util.getPlayer().insertCartridge(type, sizeKB);
            util.getPlayer().play(RESET);
        } catch (IOException ex) {
            System.err.printf("Cannot insert cartridge of type '%s' and size '%d'KB.%n", type.name(), sizeKB);
        }
    }

    private void insertCartridge(InputStream is) {
        try {
            util.getPlayer().insertCartridgeCRT(is);
            util.getPlayer().play(RESET);
        } catch (IOException ex) {
            System.err.println("Cannot insert cartridge of type 'CRT'.");
        }
    }

    private void createHardCopy(String format) {
        video();
        try {
            Image vicImage = Video.getVicImage();
            if (vicImage != null) {
                File file = new File(util.getConfig().getSidplay2Section().getTmpDir(),
                        "screenshot" + (++hardcopyCounter) + "." + format);
                // Workaround Java8 bug (Remove an alpha-channel from jpg)
                if (format.equals("jpg")) {
                    BufferedImage image = SwingFXUtils.fromFXImage(vicImage, null);
                    BufferedImage vicImageRGB = new BufferedImage(image.getWidth(), image.getHeight(),
                            Transparency.OPAQUE);
                    Graphics2D graphics = vicImageRGB.createGraphics();
                    graphics.drawImage(image, 0, 0, null);
                    ImageIO.write(vicImageRGB, format, file);
                    graphics.dispose();
                } else {
                    ImageIO.write(SwingFXUtils.fromFXImage(vicImage, null), format, file);
                }
                DesktopUtil.open(file);
            } else {
                System.err.println("Screenshot not possible, there is currently no frame!");
            }
        } catch (IOException e) {
            openErrorDialog(String.format(util.getBundle().getString("ERR_IO_WRITE_ERROR"), e.getMessage()));
        }
    }

    private void updateWarpControls() {
        boolean active = util.getPlayer().isWarp();
        warp.setSelected(active);
        warp.setDisable(!util.getPlayer().isWarpSupported());
        warpStatus.setVisible(active);
        normalSpeed.setDisable(active || !(util.getPlayer().stateProperty().get() == State.PLAY
                || util.getPlayer().stateProperty().get() == State.PAUSE));
        fastForward.setDisable(normalSpeed.isDisable());
        btnFastForward.setDisable(normalSpeed.isDisable());
    }

    private void updatePlayerButtons(State state, boolean isFastForward) {
        SidPlay2Section sidplay2Section = util.getConfig().getSidplay2Section();

        SidTune sidTune = util.getPlayer().getTune();
        PlayList playList = util.getPlayer().getPlayList();

        btnNextFavoriteDisabledState.set(sidTune == RESET || state == State.QUIT
                || sidplay2Section.getPlaybackType() == PlaybackType.PLAYBACK_OFF);
        btnNextSongDisabledState.set(sidTune == RESET || state == State.QUIT);

        boolean isPlayOrPause = state == State.PLAY || state == State.PAUSE;

        pauseContinue.setSelected(state == State.PAUSE);
        previousSong.setDisable(btnNextSongDisabledState.get() || !playList.hasPrevious());
        previousSong.setText(String.format(util.getBundle().getString("PREVIOUS_SONG") + " (%d/%d)",
                playList.getPrevious(), playList.getLength()));
        nextSong.setDisable(btnNextSongDisabledState.get() || !playList.hasNext());
        nextSong.setText(String.format(util.getBundle().getString("NEXT_SONG") + " (%d/%d)", playList.getNext(),
                playList.getLength()));
        normalSpeed.setSelected(!(isPlayOrPause && isFastForward));
        normalSpeed.setDisable(!isPlayOrPause);
        fastForward.setDisable(!isPlayOrPause);
        fastForward.setSelected(isPlayOrPause && isFastForward);
        stop.setDisable(!isPlayOrPause);

        btnPlay.setDisable(state == State.PLAY);
        btnPause.setDisable(state != State.PLAY);
        btnFastForward.setDisable(!isPlayOrPause);
        btnFastForward.setSelected(isPlayOrPause && isFastForward);
        btnStop.setDisable(!isPlayOrPause);
        btnPreviousSong.setDisable(previousSong.isDisable());
        btnPreviousSongToolTip.setText(String.format(util.getBundle().getString("BTN_PREVIOUS_SONG") + " (%d/%d)",
                playList.getPrevious(), playList.getLength()));
        btnNextSong.setDisable(nextSong.isDisable());
        btnNextSongToolTip.setText(String.format(util.getBundle().getString("BTN_NEXT_SONG") + " (%d/%d)",
                playList.getNext(), playList.getLength()));

        saveTune.setDisable(sidTune == RESET);
        updateWarpControls();
    }

    private void setCurrentTrack(SidTune sidTune) {
        StringBuilder trackInfo = new StringBuilder();
        StringBuilder trackInfoToolTip = new StringBuilder();
        if (sidTune != RESET) {
            SidTuneInfo info = sidTune.getInfo();
            Iterator<String> detail = info.getInfoString().iterator();
            if (detail.hasNext()) {
                String title = detail.next();
                trackInfo.append(title).append(' ');
                trackInfoToolTip.append(title).append('\n');
            }
            if (detail.hasNext()) {
                trackInfoToolTip.append(detail.next()).append('\n');
            }
            if (detail.hasNext()) {
                trackInfoToolTip.append(detail.next());
            }
            trackInfo.append(String.format("%2d/%2d", info.getCurrentSong(), info.getSongs()));
        }
        tracks.setText(trackInfo.toString());
        tracks.setTooltip(new Tooltip(trackInfoToolTip.toString()));
    }

    private void openErrorDialog(String msg) {
        Alert alert = new Alert(AlertType.ERROR, msg);
        alert.setTitle(util.getBundle().getString("ALERT_TITLE"));
        alert.showAndWait();
    }
}