HatariWii/python-ui/hatari.py

#!/usr/bin/env python
#
# Classes for Hatari emulator instance and mapping its congfiguration
# variables with its command line option.
#
# Copyright (C) 2008-2015 by Eero Tamminen
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

import os
import sys
import time
import signal
import socket
import select
from config import ConfigStore


# Running Hatari instance
class Hatari:
    "running hatari instance and methods for communicating with it"
    basepath = "/tmp/hatari-ui-" + str(os.getpid())
    logpath = basepath + ".log"
    tracepath = basepath + ".trace"
    debugpath = basepath + ".debug"
    controlpath = basepath + ".socket"
    server = None # singleton due to path being currently one per user

    def __init__(self, hataribin = None):
        # collect hatari process zombies without waitpid()
        signal.signal(signal.SIGCHLD, signal.SIG_IGN)
        if hataribin:
            self.hataribin = hataribin
        else:
            self.hataribin = "hatari"
        self._create_server()
        self.control = None
        self.paused = False
        self.pid = 0

    def is_compatible(self):
        "check Hatari compatibility and return error string if it's not"
        error = "Hatari not found or it doesn't support the required --control-socket option!"
        pipe = os.popen(self.hataribin + " -h")
        for line in pipe.readlines():
            if line.find("--control-socket") >= 0:
                error = None
                break
        try:
            pipe.close()
        except IOError:
            pass
        return error

    def save_config(self):
        os.popen(self.hataribin + " --saveconfig")

    def _create_server(self):
        if self.server:
            return
        self.server = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
        if os.path.exists(self.controlpath):
            os.unlink(self.controlpath)
        self.server.bind(self.controlpath)
        self.server.listen(1)
        
    def _send_message(self, msg):
        if self.control:
            self.control.send(msg)
            return True
        else:
            print("ERROR: no Hatari (control socket)")
            return False
        
    def change_option(self, option):
        "change_option(option), changes given Hatari cli option"
        return self._send_message("hatari-option %s\n" % option)
        
    def set_path(self, key, path):
        "set_path(key, path), sets path with given key"
        return self._send_message("hatari-path %s %s\n" % (key, path))

    def set_device(self, device, enabled):
        # needed because CLI options cannot disable devices, only enable
        "set_path(device, enabled), sets whether given device is enabled or not"
        if enabled:
            return self._send_message("hatari-enable %s\n" % device)
        else:
            return self._send_message("hatari-disable %s\n" % device)
        
    def trigger_shortcut(self, shortcut):
        "trigger_shortcut(shortcut), triggers given Hatari (keyboard) shortcut"
        return self._send_message("hatari-shortcut %s\n" % shortcut)

    def insert_event(self, event):
        "insert_event(event), synthetizes given key/mouse Atari event"
        return self._send_message("hatari-event %s\n" % event)

    def debug_command(self, cmd):
        "debug_command(command), runs given Hatari debugger command"
        return self._send_message("hatari-debug %s\n" % cmd)

    def pause(self):
        "pause(), pauses Hatari emulation"
        return self._send_message("hatari-stop\n")

    def unpause(self):
        "unpause(), continues Hatari emulation"
        return self._send_message("hatari-cont\n")
    
    def _open_output_file(self, hataricommand, option, path):
        if os.path.exists(path):
            os.unlink(path)
        # TODO: why fifo doesn't work properly (blocks forever on read or
        #       reads only byte at the time and stops after first newline)?
        #os.mkfifo(path)
        #raw_input("attach strace now, then press Enter\n")
        
        # ask Hatari to open/create the requested output file...
        hataricommand("%s %s" % (option, path))
        wait = 0.025
        # ...and wait for it to appear before returning it
        for i in range(0, 8):
            time.sleep(wait)
            if os.path.exists(path):
                return open(path, "r")
            wait += wait
        return None

    def open_debug_output(self):
        "open_debug_output() -> file, opens Hatari debugger output file"
        return self._open_output_file(self.debug_command, "f", self.debugpath)

    def open_trace_output(self):
        "open_trace_output() -> file, opens Hatari tracing output file"
        return self._open_output_file(self.change_option, "--trace-file", self.tracepath)

    def open_log_output(self):
        "open_trace_output() -> file, opens Hatari debug log file"
        return self._open_output_file(self.change_option, "--log-file", self.logpath)
    
    def get_lines(self, fileobj):
        "get_lines(file) -> list of lines readable from given Hatari output file"
        # wait until data is available, then wait for some more
        # and only then the data can be read, otherwise its old
        print("Request&wait data from Hatari...")
        select.select([fileobj], [], [])
        time.sleep(0.1)
        print("...read the data lines")
        lines = fileobj.readlines()
        print("".join(lines))
        return lines

    def enable_embed_info(self):
        "enable_embed_info(), request embedded Hatari window ID change information"
        self._send_message("hatari-embed-info\n")

    def get_embed_info(self):
        "get_embed_info() -> (width, height), get embedded Hatari window size"
        width, height = self.control.recv(12).split("x")
        return (int(width), int(height))

    def get_control_socket(self):
        "get_control_socket() -> socket which can be checked for embed ID changes"
        return self.control
        
    def is_running(self):
        "is_running() -> bool, True if Hatari is running, False otherwise"
        if not self.pid:
            return False
        try:
            os.waitpid(self.pid, os.WNOHANG)
        except OSError as value:
            print("Hatari PID %d had exited in the meanwhile:\n\t%s" % (self.pid, value))
            self.pid = 0
            if self.control:
                self.control.close()
                self.control = None
            return False
        return True
    
    def run(self, extra_args = None, parent_win = None):
        "run([parent window][,embedding args]), runs Hatari"
        # if parent_win given, embed Hatari to it
        pid = os.fork()
        if pid < 0:
            print("ERROR: fork()ing Hatari failed!")
            return
        if pid:
            # in parent
            self.pid = pid
            if self.server:
                print("WAIT hatari to connect to control socket...")
                (self.control, addr) = self.server.accept()
                print("connected!")
        else:
            # child runs Hatari
            env = os.environ
            if parent_win:
                self._set_embed_env(env, parent_win)
            # callers need to take care of confirming quitting
            args = [self.hataribin, "--confirm-quit", "off"]
            if self.server:
                args += ["--control-socket", self.controlpath]
            if extra_args:
                args += extra_args
            print("RUN:", args)
            os.execvpe(self.hataribin, args, env)

    def _set_embed_env(self, env, parent_win):
        if sys.platform == 'win32':
            win_id = parent_win.handle
        else:
            win_id = parent_win.xid
        # tell SDL to use given widget's window
        #env["SDL_WINDOWID"] = str(win_id)

        # above is broken: when SDL uses a window it hasn't created itself,
        # it for some reason doesn't listen to any events delivered to that
        # window nor implements XEMBED protocol to get them in a way most
        # friendly to embedder:
        #   http://standards.freedesktop.org/xembed-spec/latest/
        #
        # Instead we tell hatari to reparent itself after creating
        # its own window into this program widget window
        env["PARENT_WIN_ID"] = str(win_id)

    def kill(self):
        "kill(), kill Hatari if it's running"
        if self.is_running():
            os.kill(self.pid, signal.SIGKILL)
            print("killed hatari with PID %d" % self.pid)
            self.pid = 0
        if self.control:
            self.control.close()
            self.control = None


# Mapping of requested values both to Hatari configuration
# and command line options.
#
# By default this doesn't allow setting any other configuration
# variables than the ones that were read from the configuration
# file i.e. you get an exception if configuration variables
# don't match to current Hatari.  So before using this the current
# Hatari configuration should have been saved at least once.
#
# Because of some inconsistencies in the values (see e.g. sound),
# this cannot just do these according to some mapping table, but
# it needs actual method for (each) setting.
class HatariConfigMapping(ConfigStore):
    _paths = {
        "memauto": ("[Memory]", "szAutoSaveFileName", "Automatic memory snapshot"),
        "memsave": ("[Memory]", "szMemoryCaptureFileName", "Manual memory snapshot"),
        "midiin":  ("[Midi]", "sMidiInFileName", "Midi input"),
        "midiout": ("[Midi]", "sMidiOutFileName", "Midi output"),
        "rs232in": ("[RS232]", "szInFileName", "RS232 I/O input"),
        "rs232out": ("[RS232]", "szOutFileName", "RS232 I/O output"),
        "printout": ("[Printer]", "szPrintToFileName", "Printer output"),
        "soundout": ("[Sound]", "szYMCaptureFileName", "Sound output")
    }
    "access methods to Hatari configuration file variables and command line options"
    def __init__(self, hatari):
        userconfdir = ".hatari"
        ConfigStore.__init__(self, userconfdir)
        conffilename = "hatari.cfg"
        self.load(self.get_filepath(conffilename))

        self._hatari = hatari
        self._lock_updates = False
        self._desktop_w = 0
        self._desktop_h = 0
        self._options = []

    def validate(self):
        "exception is thrown if the loaded configuration isn't compatible"
        for method in dir(self):
            if '_' not in method:
                continue
            # check class getters
            starts = method[:method.find("_")]
            if starts != "get":
                continue
            # but ignore getters for other things than config
            ends = method[method.rfind("_")+1:]
            if ends in ("types", "names", "values", "changes", "checkpoint", "filepath"):
                continue
            if ends in ("floppy", "joystick"):
                # use port '0' for checks
                getattr(self, method)(0)
            else:
                getattr(self, method)()

    def _change_option(self, option, quoted = None):
        "handle option changing, and quote spaces for quoted part of it"
        if quoted:
            option = "%s %s" % (option, quoted.replace(" ", "\\ "))
        if self._lock_updates:
            self._options.append(option)
        else:
            self._hatari.change_option(option)

    def lock_updates(self):
        "lock_updates(), collect Hatari configuration changes"
        self._lock_updates = True
    
    def flush_updates(self):
        "flush_updates(), apply collected Hatari configuration changes"
        self._lock_updates = False
        if not self._options:
            return
        self._hatari.change_option(" ".join(self._options))
        self._options = []

    # ------------ paths ---------------
    def get_paths(self):
        paths = []
        for key, item in self._paths.items():
            paths.append((key, self.get(item[0], item[1]), item[2]))
        return paths
    
    def set_paths(self, paths):
        for key, path in paths:
            self.set(self._paths[key][0], self._paths[key][1], path)
            self._hatari.set_path(key, path)

    # ------------ midi ---------------
    def get_midi(self):
        return self.get("[Midi]", "bEnableMidi")

    def set_midi(self, value):
        self.set("[Midi]", "bEnableMidi", value)
        self._hatari.set_device("midi", value)

    # ------------ printer ---------------
    def get_printer(self):
        return self.get("[Printer]", "bEnablePrinting")

    def set_printer(self, value):
        self.set("[Printer]", "bEnablePrinting", value)
        self._hatari.set_device("printer", value)

    # ------------ RS232 ---------------
    def get_rs232(self):
        return self.get("[RS232]", "bEnableRS232")

    def set_rs232(self, value):
        self.set("[RS232]", "bEnableRS232", value)
        self._hatari.set_device("rs232", value)

    # ------------ machine ---------------
    def get_machine_types(self):
        return ("ST", "STE", "TT", "Falcon")

    def get_machine(self):
        return self.get("[System]", "nMachineType")

    def set_machine(self, value):
        self.set("[System]", "nMachineType", value)
        self._change_option("--machine %s" % ("st", "ste", "tt", "falcon")[value])

    # ------------ CPU level ---------------
    def get_cpulevel_types(self):
        return ("68000", "68010", "68020", "68EC030+FPU", "68040")

    def get_cpulevel(self):
        return self.get("[System]", "nCpuLevel")

    def set_cpulevel(self, value):
        self.set("[System]", "nCpuLevel", value)
        self._change_option("--cpulevel %d" % value)

    # ------------ CPU clock ---------------
    def get_cpuclock_types(self):
        return ("8 MHz", "16 MHz", "32 MHz") 

    def get_cpuclock(self):
        clocks = {8:0, 16: 1, 32:2}
        return clocks[self.get("[System]", "nCpuFreq")]

    def set_cpuclock(self, value):
        clocks = [8, 16, 32]
        if value < 0 or value > 2:
            print("WARNING: CPU clock idx %d, clock fixed to 8 Mhz" % value)
            value = 8
        else:
            value = clocks[value]
        self.set("[System]", "nCpuFreq", value)
        self._change_option("--cpuclock %d" % value)

    # ------------ DSP type ---------------
    def get_dsp_types(self):
        return ("None", "Dummy", "Emulated")

    def get_dsp(self):
        return self.get("[System]", "nDSPType")

    def set_dsp(self, value):
        self.set("[System]", "nDSPType", value)
        self._change_option("--dsp %s" % ("none", "dummy", "emu")[value])

    # ------------ compatible ---------------
    def get_compatible(self):
        return self.get("[System]", "bCompatibleCpu")

    def set_compatible(self, value):
        self.set("[System]", "bCompatibleCpu", value)
        self._change_option("--compatible %s" % str(value))

    # ------------ Timer-D ---------------
    def get_timerd(self):
        return self.get("[System]", "bPatchTimerD")

    def set_timerd(self, value):
        self.set("[System]", "bPatchTimerD", value)
        self._change_option("--timer-d %s" % str(value))

    # ------------ RTC ---------------
    def get_rtc(self):
        return self.get("[System]", "bRealTimeClock")

    def set_rtc(self, value):
        self.set("[System]", "bRealTimeClock", value)
        self._change_option("--rtc %s" % str(value))

    # ------------ fastforward ---------------
    def get_fastforward(self):
        return self.get("[System]", "bFastForward")

    def set_fastforward(self, value):
        self.set("[System]", "bFastForward", value)
        self._change_option("--fast-forward %s" % str(value))
        
    # ------------ sound ---------------
    def get_sound_values(self):
        # 48kHz, 44.1kHz and STE/TT/Falcon DMA 50066Hz divisable values
        return ("6000", "6258", "8000", "11025", "12000", "12517",
                "16000", "22050", "24000", "25033", "32000",
                "44100", "48000", "50066")
    
    def get_sound(self):
        enabled = self.get("[Sound]", "bEnableSound")
        hz = str(self.get("[Sound]", "nPlaybackFreq"))
        idx = self.get_sound_values().index(hz)
        return (enabled, idx)

    def set_sound(self, enabled, idx):
        # map get_sound_values() index to Hatari config
        hz = self.get_sound_values()[idx]
        self.set("[Sound]", "nPlaybackFreq", int(hz))
        self.set("[Sound]", "bEnableSound", enabled)
        # and to cli option
        if enabled:
            self._change_option("--sound %s" % hz)
        else:
            self._change_option("--sound off")
    
    def get_ymmixer_types(self):
        return ("linear", "table", "model")
    
    def get_ymmixer(self):
        # values for types are start from 1, not 0
        return self.get("[Sound]", "YmVolumeMixing")-1
    
    def set_ymmixer(self, value):
        self.set("[Sound]", "YmVolumeMixing", value+1)
        self._change_option("--ym-mixing %s" % self.get_ymmixer_types()[value])
    
    def get_bufsize(self):
        return self.get("[Sound]", "nSdlAudioBufferSize")
    
    def set_bufsize(self, value):
        value = int(value)
        if value < 10: value = 10
        if value > 100: value = 100
        self.set("[Sound]", "nSdlAudioBufferSize", value)
        self._change_option("--sound-buffer-size %d" % value)
    
    def get_sync(self):
        return self.get("[Sound]", "bEnableSoundSync")
    
    def set_sync(self, value):
        self.set("[Sound]", "bEnableSoundSync", value)
        self._change_option("--sound-sync %s" % str(value))

    def get_mic(self):
        return self.get("[Sound]", "bEnableMicrophone")
    
    def set_mic(self, value):
        self.set("[Sound]", "bEnableMicrophone", value)
        self._change_option("--mic %s" % str(value))

    # ----------- joystick --------------
    def get_joystick_types(self):
        return ("Disabled", "Real joystick", "Keyboard")
    
    def get_joystick_names(self):
        return (
        "ST Joystick 0",
        "ST Joystick 1",
        "STE Joypad A",
        "STE Joypad B",
        "Parport stick 1",
        "Parport stick 2"
        )

    def get_joystick(self, port):
        # return index to get_joystick_values() array
        return self.get("[Joystick%d]" % port, "nJoystickMode")

    def set_joystick(self, port, value):
        # map get_sound_values() index to Hatari config
        self.set("[Joystick%d]" % port, "nJoystickMode", value)
        joytype = ("none", "real", "keys")[value]
        self._change_option("--joy%d %s" % (port, joytype))

    # ------------ floppy handling ---------------
    def get_floppydir(self):
        return self.get("[Floppy]", "szDiskImageDirectory")
    
    def set_floppydir(self, path):
        return self.set("[Floppy]", "szDiskImageDirectory", path)

    def get_floppy(self, drive):
        return self.get("[Floppy]", "szDisk%cFileName" % ("A", "B")[drive])
    
    def set_floppy(self, drive, filename):
        self.set("[Floppy]", "szDisk%cFileName" %  ("A", "B")[drive], filename)
        self._change_option("--disk-%c" % ("a", "b")[drive], str(filename))

    def get_floppy_drives(self):
        return (self.get("[Floppy]", "EnableDriveA"), self.get("[Floppy]", "EnableDriveB"))

    def set_floppy_drives(self, drives):
        idx = 0
        for drive in ("A", "B"):
            value = drives[idx]
            self.set("[Floppy]", "EnableDrive%c" % drive, value)
            self._change_option("--drive-%c %s" % (drive.lower(), str(value)))
            idx += 1

    def get_fastfdc(self):
        return self.get("[Floppy]", "FastFloppy")

    def set_fastfdc(self, value):
        self.set("[Floppy]", "FastFloppy", value)
        self._change_option("--fastfdc %s" % str(value))

    def get_doublesided(self):
        driveA = self.get("[Floppy]", "DriveA_NumberOfHeads")
        driveB = self.get("[Floppy]", "DriveB_NumberOfHeads")
        if driveA > 1 or driveB > 1:
            return True
        return False
    
    def set_doublesided(self, value):
        if value: sides = 2
        else:     sides = 1
        for drive in ("A", "B"):
            self.set("[Floppy]", "Drive%c_NumberOfHeads" % drive, sides)
            self._change_option("--drive-%c-heads %d" % (drive.lower(), sides))

    # ------------- disk protection -------------
    def get_protection_types(self):
        return ("Off", "On", "Auto")

    def get_floppy_protection(self):
        return self.get("[Floppy]", "nWriteProtection")

    def get_hd_protection(self):
        return self.get("[HardDisk]", "nWriteProtection")

    def set_floppy_protection(self, value):
        self.set("[Floppy]", "nWriteProtection", value)
        self._change_option("--protect-floppy %s" % self.get_protection_types()[value])

    def set_hd_protection(self, value):
        self.set("[HardDisk]", "nWriteProtection", value)
        self._change_option("--protect-hd %s" % self.get_protection_types()[value])

    # ------------ GEMDOS HD (dir) emulation ---------------
    def get_hd_cases(self):
        return ("No conversion", "Upper case", "Lower case")

    def get_hd_case(self):
        return self.get("[HardDisk]", "nGemdosCase")

    def set_hd_case(self, value):
        values = ("off", "upper", "lower")
        self.set("[HardDisk]", "nGemdosCase", value)
        self._change_option("--gemdos-case %s" % values[value])

    def get_hd_drives(self):
        return ['skip ACSI/IDE'] + [("%c:" % x) for x in range(ord('C'), ord('Z')+1)]

    def get_hd_drive(self):
        return self.get("[HardDisk]", "nGemdosDrive") + 1

    def set_hd_drive(self, value):
        value -= 1
        self.set("[HardDisk]", "nGemdosDrive", value)
        drive = chr(ord('C') + value)
        if value < 0:
            drive = "skip"
        self._change_option("--gemdos-drive %s" % drive)

    def get_hd_dir(self):
        self.get("[HardDisk]", "bUseHardDiskDirectory") # for validation
        return self.get("[HardDisk]", "szHardDiskDirectory")

    def set_hd_dir(self, dirname):
        if dirname and os.path.isdir(dirname):
            self.set("[HardDisk]", "bUseHardDiskDirectory", True)
        self.set("[HardDisk]", "szHardDiskDirectory", dirname)
        self._change_option("--harddrive", str(dirname))

    # ------------ ACSI HD (file) ---------------
    def get_acsi_image(self):
        self.get("[HardDisk]", "bUseHardDiskImage") # for validation
        return self.get("[HardDisk]", "szHardDiskImage")

    def set_acsi_image(self, filename):
        if filename and os.path.isfile(filename):
            self.set("[HardDisk]", "bUseHardDiskImage", True)
        self.set("[HardDisk]", "szHardDiskImage", filename)
        self._change_option("--acsi", str(filename))

    # ------------ IDE master (file) ---------------
    def get_idemaster_image(self):
        self.get("[HardDisk]", "bUseIdeMasterHardDiskImage") # for validation
        return self.get("[HardDisk]", "szIdeMasterHardDiskImage")

    def set_idemaster_image(self, filename):
        if filename and os.path.isfile(filename):
            self.set("[HardDisk]", "bUseIdeMasterHardDiskImage", True)
        self.set("[HardDisk]", "szIdeMasterHardDiskImage", filename)
        self._change_option("--ide-master", str(filename))

    # ------------ IDE slave (file) ---------------
    def get_ideslave_image(self):
        self.get("[HardDisk]", "bUseIdeSlaveHardDiskImage") # for validation
        return self.get("[HardDisk]", "szIdeSlaveHardDiskImage")

    def set_ideslave_image(self, filename):
        if filename and os.path.isfile(filename):
            self.set("[HardDisk]", "bUseIdeSlaveHardDiskImage", True)
        self.set("[HardDisk]", "szIdeSlaveHardDiskImage", filename)
        self._change_option("--ide-slave", str(filename))

    # ------------ TOS ROM ---------------
    def get_tos(self):
        return self.get("[ROM]", "szTosImageFileName")
    
    def set_tos(self, filename):
        self.set("[ROM]", "szTosImageFileName", filename)
        self._change_option("--tos", str(filename))

    # ------------ memory ---------------
    def get_memory_names(self):
        # empty item in list shouldn't be shown, filter them out
        return ("512kB", "1MB", "2MB", "4MB", "8MB", "14MB")

    def get_memory(self):
        "return index to what get_memory_names() returns"
        sizemap = (0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5)
        memsize = self.get("[Memory]", "nMemorySize")
        if memsize >= 0 and memsize < len(sizemap):
            return sizemap[memsize]
        return 1 # default = 1BM

    def set_memory(self, idx):
        # map memory item index to memory size
        sizemap = (0, 1, 2, 4, 8, 14)
        if idx >= 0 and idx < len(sizemap):
            memsize = sizemap[idx]
        else:
            memsize = 1
        self.set("[Memory]", "nMemorySize", memsize)
        self._change_option("--memsize %d" % memsize)

    def get_ttram(self):
        return self.get("[Memory]", "nTTRamSize")

    def set_ttram(self, memsize):
        # guarantee correct type (Gtk float -> config int)
        memsize = int(memsize)
        self.set("[Memory]", "nTTRamSize", memsize)
        self._change_option("--ttram %d" % memsize)
        if memsize:
            # TT-RAM need 32-bit addressing (i.e. disable 24-bit)
            self.set("[System]", "bAddressSpace24", False)
            self._change_option("--addr24 off")
        else:
            # switch 24-bit addressing back for compatibility
            self.set("[System]", "bAddressSpace24", True)
            self._change_option("--addr24 on", False)

    # ------------ monitor ---------------
    def get_monitor_types(self):
        return ("Mono", "RGB", "VGA", "TV")

    def get_monitor(self):
        return self.get("[Screen]", "nMonitorType")

    def set_monitor(self, value):
        self.set("[Screen]", "nMonitorType", value)
        self._change_option("--monitor %s" % ("mono", "rgb", "vga", "tv")[value])

    # ------------ frameskip ---------------
    def get_frameskip_names(self):
        return (
            "Disabled",
            "1 frame",
            "2 frames",
            "3 frames",
            "4 frames",
            "Automatic"
        )
    
    def get_frameskip(self):
        fs = self.get("[Screen]", "nFrameSkips")
        if fs < 0 or fs > 5:
            return 5
        return fs
    
    def set_frameskip(self, value):
        value = int(value) # guarantee correct type
        self.set("[Screen]", "nFrameSkips", value)
        self._change_option("--frameskips %d" % value)

    # ------------ VBL slowdown ---------------
    def get_slowdown_names(self):
        return ("Disabled", "2x", "3x", "4x", "5x", "6x", "8x")
    
    def set_slowdown(self, value):
        value = 1 + int(value)
        self._change_option("--slowdown %d" % value)

    # ------------ spec512 ---------------
    def get_spec512threshold(self):
        return self.get("[Screen]", "nSpec512Threshold")

    def set_spec512threshold(self, value):
        value = int(value) # guarantee correct type
        self.set("[Screen]", "nSpec512Threshold", value)
        self._change_option("--spec512 %d" % value)

    # --------- keep desktop res -----------
    def get_desktop(self):
        return self.get("[Screen]", "bKeepResolution")
    
    def set_desktop(self, value):
        self.set("[Screen]", "bKeepResolution", value)
        self._change_option("--desktop %s" % str(value))

    # --------- keep desktop res - st ------
    def get_desktop_st(self):
        return self.get("[Screen]", "bKeepResolutionST")
    
    def set_desktop_st(self, value):
        self.set("[Screen]", "bKeepResolutionST", value)
        self._change_option("--desktop-st %s" % str(value))

    # ------------ force max ---------------
    def get_force_max(self):
        return self.get("[Screen]", "bForceMax")
    
    def set_force_max(self, value):
        self.set("[Screen]", "bForceMax", value)
        self._change_option("--force-max %s" % str(value))

    # ------------ show borders ---------------
    def get_borders(self):
        return self.get("[Screen]", "bAllowOverscan")
    
    def set_borders(self, value):
        self.set("[Screen]", "bAllowOverscan", value)
        self._change_option("--borders %s" % str(value))

    # ------------ show statusbar ---------------
    def get_statusbar(self):
        return self.get("[Screen]", "bShowStatusbar")
    
    def set_statusbar(self, value):
        self.set("[Screen]", "bShowStatusbar", value)
        self._change_option("--statusbar %s" % str(value))

    # ------------ crop statusbar ---------------
    def get_crop(self):
        return self.get("[Screen]", "bCrop")
    
    def set_crop(self, value):
        self.set("[Screen]", "bCrop", value)
        self._change_option("--crop %s" % str(value))

    # ------------ show led ---------------
    def get_led(self):
        return self.get("[Screen]", "bShowDriveLed")
    
    def set_led(self, value):
        self.set("[Screen]", "bShowDriveLed", value)
        self._change_option("--drive-led %s" % str(value))

    # ------------ monitor aspect ratio ---------------
    def get_aspectcorrection(self):
        return self.get("[Screen]", "bAspectCorrect")
    
    def set_aspectcorrection(self, value):
        self.set("[Screen]", "bAspectCorrect", value)
        self._change_option("--aspect %s" % str(value))

    # ------------ max window size ---------------
    def set_desktop_size(self, w, h):
        self._desktop_w = w
        self._desktop_h = h
        
    def get_desktop_size(self):
        return (self._desktop_w, self._desktop_h)

    def get_max_size(self):
        w = self.get("[Screen]", "nMaxWidth")
        h = self.get("[Screen]", "nMaxHeight")
        # default to desktop size?
        if not (w or h):
            w = self._desktop_w
            h = self._desktop_h
        return (w, h)

    def set_max_size(self, w, h):
        # guarantee correct type (Gtk float -> config int)
        w = int(w); h = int(h)
        self.set("[Screen]", "nMaxWidth", w)
        self.set("[Screen]", "nMaxHeight", h)
        self._change_option("--max-width %d" % w)
        self._change_option("--max-height %d" % h)

    # TODO: remove once UI doesn't need this anymore
    def set_zoom(self, value):
        print("Just setting Zoom, configuration doesn't anymore have setting for this.")
        if value:
            zoom = 2
        else:
            zoom = 1
        self._change_option("--zoom %d" % zoom)

    # ------------ configured Hatari window size ---------------
    def get_window_size(self):
        if self.get("[Screen]", "bFullScreen"):
            print("WARNING: don't start Hatari UI with fullscreened Hatari!")

        # VDI resolution?
        if self.get("[Screen]", "bUseExtVdiResolutions"):
            width = self.get("[Screen]", "nVdiWidth")
            height = self.get("[Screen]", "nVdiHeight")
            return (width, height)
        
        # window sizes for other than ST & STE can differ
        if self.get("[System]", "nMachineType") not in (0, 1):
            print("WARNING: neither ST nor STE machine, window size inaccurate!")
            videl = True
        else:
            videl = False

        # mono monitor?
        if self.get_monitor() == 0:
            return (640, 400)

        # no, color
        width = 320
        height = 200
        # statusbar?
        if self.get_statusbar():
            sbar = 12
            height += sbar
        else:
            sbar = 0
        # zoom?
        maxw, maxh = self.get_max_size()
        if 2*width <= maxw and 2*height <= maxh:
            width *= 2
            height *= 2
            zoom = 2
        else:
            zoom = 1
        # overscan borders?
        if self.get_borders() and not videl:
            # properly aligned borders on top of zooming
            leftx = (maxw-width)/zoom
            borderx = 2*(min(48,leftx/2)/16)*16
            lefty = (maxh-height)/zoom
            bordery = min(29+47, lefty)
            width += zoom*borderx
            height += zoom*bordery

        return (width, height)