def update_default_device(self, had_default=None):
config = {"platform": self._platform}
for port in range(1, 4 + 1):
key = "{}_port_{}".format(self._platform, port)
if self.port == port:
config[key] = ""
else:
config[key] = LauncherConfig.get(key)
key = "{}_port_{}_type".format(self._platform, port)
config[key] = LauncherConfig.get(key)
# config[key] = DeviceManager.get_calculated_port_mode(
# LauncherConfig, port)
device = DeviceManager.get_non_amiga_device_for_port(config, self.port)
default_description = "{} (*)".format(fix_device_name(device.name))
# print("default_description = ", default_description)
if had_default is None:
had_default = (self.get_index() == 0)
# print("had default", had_default, self.get_index())
self.set_item_text(0, default_description)
# print("had_default", had_default)
if had_default:
# print("set text for", self.port, default_description)
# self.set_index(1)
self.set_text(default_description)
self.set_index(0)
def get_initial_text():
text = ""
# FIXME: accessing values directly here, not very nice
keys = app.settings.values.keys()
for key in sorted(keys):
if key in LauncherSettings.default_settings:
continue
# if key in LauncherConfig.config_keys:
# # print("(settings) ignoring key", key)
# text += "\n# {0} is ignored here " \
# "(use config dialog instead)\n".format(key)
if LauncherConfig.is_config_only_option(key):
text += (
"\n# {0} will here function as a global config "
"default and may cause\nunexpected problems. It is "
"recommended to only use this as a per-config "
"option.\n".format(key)
)
value = app.settings[key]
if LauncherConfig.get(key):
text += (
"\n# {0} is overridden by current "
"configuration\n".format(key)
)
text += "{0} = {1}\n".format(key, value)
if LauncherConfig.get(key):
text += "\n"
if key in LauncherConfig.config_keys:
text += "\n"
return text
def __init__(self, parent):
StatusElement.__init__(self, parent)
self.error_icon = Image("launcher:res/16/error.png")
self.warning_icon = Image("launcher:res/16/warning_3.png")
self.notice_icon = Image("launcher:res/16/information.png")
self.icons = [
self.error_icon,
self.warning_icon,
self.notice_icon,
]
self.coordinates = []
self.warnings = []
self.game_notice = ""
self.variant_notice = ""
self.variant_warning = ""
self.variant_error = ""
self.joy_emu_conflict = ""
self.using_joy_emu = False
self.kickstart_file = ""
self.x_kickstart_file_sha1 = ""
self.update_available = ""
self.__error = ""
self.x_missing_files = ""
self.download_page = ""
self.download_file = ""
self.amiga_model = ""
self.amiga_model_calculated = ""
self.chip_memory = ""
self.chip_memory_calculated = 0
self.outdated_plugins = []
self.custom_config = set()
self.custom_uae_config = set()
self.settings_config_keys = set()
plugin_manager = PluginManager.instance()
for plugin in plugin_manager.plugins():
if plugin.outdated:
self.outdated_plugins.append(plugin.name)
ConfigBehavior(self, [
"x_game_notice", "x_variant_notice", "x_variant_warning",
"x_variant_error", "x_joy_emu_conflict", "amiga_model",
"x_kickstart_file_sha1", "kickstart_file", "download_page",
"download_file", "x_missing_files", "__error",
"chip_memory", "jit_compiler"])
SettingsBehavior(self, ["__update_available"])
LauncherConfig.add_listener(self)
for key in JOYSTICK_KEYS:
self.on_config(key, LauncherConfig.get(key))
for key in LauncherConfig.keys():
if LauncherConfig.is_custom_uae_option(key):
self.on_config(key, LauncherConfig.get(key))
elif LauncherConfig.is_custom_option(key):
self.on_config(key, LauncherConfig.get(key))
LauncherSettings.add_listener(self)
for key in LauncherSettings.keys():
if LauncherConfig.is_config_only_option(key):
self.on_setting(key, LauncherSettings.get(key))
def center_window(cls, args, env):
# FIXME: does not really belong here (dependency loop)
from launcher.launcher_config import LauncherConfig
from launcher.launcher_settings import LauncherSettings
width = (LauncherConfig.get("window_width")
or LauncherSettings.get("window_width"))
height = (LauncherConfig.get("window_height")
or LauncherSettings.get("window_height"))
try:
width = int(width)
except:
width = 960
try:
height = int(height)
except:
height = 540
from launcher.ui.launcher_window import LauncherWindow
if LauncherWindow.current() is None:
return
main_w, main_h = LauncherWindow.current().get_size()
main_x, main_y = LauncherWindow.current().get_position()
x = main_x + (main_w - width) // 2
y = main_y + (main_h - height) // 2
# FIXME: re-implement without wx
# if windows:
# import wx
# y += wx.SystemSettings_GetMetric(wx.SYS_CAPTION_Y)
env[str("SDL_VIDEO_WINDOW_POS")] = str("{0},{1}".format(x, y))
args.append("--window-x={0}".format(x))
args.append("--window-y={0}".format(y))
def on_activate_item(self, item):
path = LauncherConfig.get(self.file_key.format(item))
sha1 = LauncherConfig.get(self.sha1_key.format(item))
if self.cd_mode:
pass
else:
fsgs.amiga.insert_floppy_in_free_drive(path, sha1=sha1)
def update_config_key(self):
if self.mode == self.CD_MODE:
self.config_key = "cdrom_drive_{}".format(self.drive)
self.config_key_sha1 = "x_cdrom_drive_{}_sha1".format(self.drive)
self.config_key_implicit = "__implicit_cdrom_drive_count"
elif self.mode == self.TAPE_MODE:
self.config_key = "tape_drive_{}".format(self.drive)
self.config_key_sha1 = "x_tape_drive_{}_sha1".format(self.drive)
self.config_key_implicit = "__implicit_tape_drive_count"
elif self.mode == self.CARTRIDGE_MODE:
if self.drive == 0:
self.config_key = Option.CARTRIDGE_SLOT
self.config_key_sha1 = "x_cartridge_slot_sha1"
else:
self.config_key = "cartridge_drive_{}".format(self.drive)
self.config_key_sha1 = "x_cartridge_drive_{}_sha1".format(
self.drive)
self.config_key_implicit = "__implicit_cartridge_drive_count"
else:
self.config_key = "floppy_drive_{}".format(self.drive)
self.config_key_sha1 = "x_floppy_drive_{}_sha1".format(self.drive)
self.config_key_implicit = \
"__implicit_uae_floppy{}type".format(self.drive)
self.on_config(self.config_key, LauncherConfig.get(self.config_key))
self.on_config(self.config_key_implicit,
LauncherConfig.get(self.config_key_implicit))
def get_initial_text():
text = ""
# FIXME: accessing values directly here, not very nice
keys = app.settings.values.keys()
for key in sorted(keys):
if key in LauncherSettings.default_settings:
continue
# if key in LauncherConfig.config_keys:
# # print("(settings) ignoring key", key)
# text += "\n# {0} is ignored here " \
# "(use config dialog instead)\n".format(key)
if LauncherConfig.is_config_only_option(key):
text += ("\n# {0} will here function as a global config "
"default and may cause\nunexpected problems. It is "
"recommended to only use this as a per-config "
"option.\n".format(key))
value = app.settings[key]
if LauncherConfig.get(key):
text += "\n# {0} is overridden by current " \
"configuration\n".format(key)
text += "{0} = {1}\n".format(key, value)
if LauncherConfig.get(key):
text += "\n"
if key in LauncherConfig.config_keys:
text += "\n"
return text
def update_environment_with_centering_info(self, env):
# FIXME: does not really belong here (dependency loop)
from launcher.launcher_config import LauncherConfig
from launcher.launcher_settings import LauncherSettings
width = (LauncherConfig.get("window_width")
or LauncherSettings.get("window_width"))
height = (LauncherConfig.get("window_height")
or LauncherSettings.get("window_height"))
try:
width = int(width)
except:
width = 960
try:
height = int(height)
except:
height = 540
from launcher.ui.launcherwindow import LauncherWindow
if LauncherWindow.current() is None:
return
main_w, main_h = LauncherWindow.current().get_size()
main_x, main_y = LauncherWindow.current().get_position()
x = main_x + (main_w - width) // 2
y = main_y + (main_h - height) // 2
# FIXME: REMOVE
env["FSGS_WINDOW_X"] = str(x)
env["FSGS_WINDOW_Y"] = str(y)
# FIXME: REMOVE
env["SDL_VIDEO_WINDOW_POS"] = str("{0},{1}".format(x, y))
env["FSGS_WINDOW_CENTER"] = "{0},{1}".format(main_x + main_w // 2,
main_y + main_h // 2)
def on_activate_item(self, item):
path = LauncherConfig.get(self.file_key.format(item))
sha1 = LauncherConfig.get(self.sha1_key.format(item))
if self.cd_mode:
pass
else:
fsgs.amiga.insert_floppy_in_free_drive(path, sha1=sha1)
def initialize_from_config(self):
self.on_config(self.device_option_key,
LauncherConfig.get(self.device_option_key))
self.on_config(self.mode_option_key,
LauncherConfig.get(self.mode_option_key))
self.on_config(self.autofire_mode_option_key,
LauncherConfig.get(self.autofire_mode_option_key))
def center_window(cls, args, env):
# FIXME: does not really belong here (dependency loop)
from launcher.launcher_config import LauncherConfig
from launcher.launcher_settings import LauncherSettings
width = (LauncherConfig.get("window_width") or
LauncherSettings.get("window_width"))
height = (LauncherConfig.get("window_height") or
LauncherSettings.get("window_height"))
try:
width = int(width)
except:
width = 960
try:
height = int(height)
except:
height = 540
from launcher.ui.launcher_window import LauncherWindow
if LauncherWindow.current() is None:
return
main_w, main_h = LauncherWindow.current().get_size()
main_x, main_y = LauncherWindow.current().get_position()
x = main_x + (main_w - width) // 2
y = main_y + (main_h - height) // 2
# FIXME: re-implement without wx
# if windows:
# import wx
# y += wx.SystemSettings_GetMetric(wx.SYS_CAPTION_Y)
env[str("SDL_VIDEO_WINDOW_POS")] = str("{0},{1}".format(x, y))
args.append("--window-x={0}".format(x))
args.append("--window-y={0}".format(y))
def on_ext_rom_type_changed(self):
index = self.ext_rom_type_choice.get_index()
if index == 0:
if LauncherConfig.get("kickstart_ext_file") == "":
return
LauncherConfig.set("kickstart_ext_file", "")
else:
LauncherConfig.set("kickstart_ext_file",
LauncherConfig.get("x_kickstart_ext_file"))
LauncherConfig.update_kickstart()
def on_ext_rom_type_changed(self):
index = self.ext_rom_type_choice.get_index()
if index == 0:
if LauncherConfig.get("kickstart_ext_file") == "":
return
LauncherConfig.set("kickstart_ext_file", "")
else:
LauncherConfig.set("kickstart_ext_file",
LauncherConfig.get("x_kickstart_ext_file"))
LauncherConfig.update_kickstart()
def add_config_warnings(self):
# FIXME: move such warnings to config model code instead
if (self.chip_memory_calculated and self.chip_memory_calculated < 2048
and self.amiga_model_calculated in ["A1200", "A4000"]):
text = gettext("{amiga_model} with < 2 MB chip memory").format(
amiga_model=self.amiga_model)
self.warnings.append((WARNING_LEVEL, text, ""))
if LauncherConfig.get("amiga_model") == "A4000/OS4":
if LauncherConfig.get("jit_compiler") == "1":
text = gettext(
"JIT compiler with a PPC-only OS is not recommended")
self.warnings.append((WARNING_LEVEL, text, ""))
def add_config_warnings(self):
# FIXME: move such warnings to config model code instead
if self.chip_memory_calculated and \
self.chip_memory_calculated < 2048 and \
self.amiga_model_calculated in ["A1200", "A4000"]:
text = gettext("{amiga_model} with < 2 MB chip memory").format(
amiga_model=self.amiga_model)
self.warnings.append((WARNING_LEVEL, text, ""))
if LauncherConfig.get("amiga_model") == "A4000/OS4":
if LauncherConfig.get("jit_compiler") == "1":
text = gettext(
"JIT compiler with a PPC-only OS is not recommended")
self.warnings.append((WARNING_LEVEL, text, ""))
def create_list(self):
items = []
if self.cd_mode:
max_items = Amiga.MAX_CDROM_IMAGES
else:
max_items = Amiga.MAX_FLOPPY_IMAGES
for i in range(max_items):
path = LauncherConfig.get(self.file_key.format(i))
sha1 = LauncherConfig.get(self.sha1_key.format(i))
if not path:
continue
items.append((path, sha1))
return items
def create_list(self):
items = []
if self.cd_mode:
max_items = Amiga.MAX_CDROM_IMAGES
else:
max_items = Amiga.MAX_FLOPPY_IMAGES
for i in range(max_items):
path = LauncherConfig.get(self.file_key.format(i))
sha1 = LauncherConfig.get(self.sha1_key.format(i))
if not path:
continue
items.append((path, sha1))
return items
def start_local_game(cls):
print("START LOCAL GAME")
print("x_missing_files", LauncherConfig.get("x_missing_files"))
if LauncherConfig.get("x_missing_files"):
if LauncherConfig.get("download_file"):
if LauncherConfig.get("download_terms") and not \
Downloader.check_terms_accepted(
LauncherConfig.get("download_file"),
LauncherConfig.get("download_terms")):
from .ui.launcherwindow import LauncherWindow
dialog = DownloadTermsDialog(LauncherWindow.current(),
fsgs)
if not dialog.show_modal():
return
elif LauncherConfig.get("download_page"):
from .ui.launcherwindow import LauncherWindow
# fsui.show_error(_("This game must be downloaded first."))
DownloadGameWindow(LauncherWindow.current(), fsgs).show()
return
else:
fsui.show_error(
gettext("This game variant cannot be started "
"because you don't have all required files."))
return
platform_id = LauncherConfig.get(Option.PLATFORM).lower()
if platform_id in AMIGA_PLATFORMS:
cls.start_local_game_amiga()
else:
cls.start_local_game_other()
def start_local_game(cls):
print("START LOCAL GAME")
print("x_missing_files", LauncherConfig.get("x_missing_files"))
if LauncherConfig.get("x_missing_files"):
if LauncherConfig.get("download_file"):
if LauncherConfig.get("download_terms") and not \
Downloader.check_terms_accepted(
LauncherConfig.get("download_file"),
LauncherConfig.get("download_terms")):
from .ui.launcher_window import LauncherWindow
dialog = DownloadTermsDialog(LauncherWindow.current(), fsgs)
if not dialog.show_modal():
return
elif LauncherConfig.get("download_page"):
from .ui.launcher_window import LauncherWindow
# fsui.show_error(_("This game must be downloaded first."))
DownloadGameWindow(LauncherWindow.current(), fsgs).show()
return
else:
fsui.show_error(
gettext("This game variant cannot be started "
"because you don't have all required files."))
return
platform_id = LauncherConfig.get("platform").lower()
amiga_platform = platform_id in ["", "amiga", "cdtv", "cd32"]
if amiga_platform:
cls.start_local_game_amiga()
else:
cls.start_local_game_other()
def on_browse(self):
if self.mode == self.CD_MODE:
title = gettext("Choose CD-ROM Image")
# default_dir = FSGSDirectories.get_cdroms_dir()
media_type = "cd"
elif self.mode == self.TAPE_MODE:
title = gettext("Choose Tape Image")
media_type = "tape"
elif self.mode == self.CARTRIDGE_MODE:
title = gettext("Choose Cartridge Image")
media_type = "cartridge"
else:
title = gettext("Choose Floppy Image")
# default_dir = FSGSDirectories.get_floppies_dir()
media_type = "floppy"
dialog = LauncherFilePicker(
self.window, title, media_type, LauncherConfig.get(self.config_key))
if not dialog.show_modal():
return
path = dialog.get_path()
if self.mode == self.CD_MODE:
fsgs.amiga.insert_cd(self.drive, path)
elif self.mode == self.FLOPPY_MODE:
fsgs.amiga.insert_floppy(self.drive, path)
else:
fsgs.config.set(self.config_key, Paths.contract_path(path))
def set_value_or_default(self, value):
if self.port == 0:
if value == "mouse":
value = ""
elif self.port == 1:
if LauncherConfig.get("amiga_model").startswith("CD32"):
default = "cd32 gamepad"
else:
default = "joystick"
if value == default:
value = ""
else:
if value == "nothing":
value = ""
if LauncherConfig.get(self.mode_option_key) != value:
LauncherConfig.set(self.mode_option_key, value)
def update_sub_models(self, model_id, sub_model_id):
sub_model_index = 0
model_id_s = model_id + "/"
self.sub_model_ids.clear()
self.sub_model_titles.clear()
for i, config in enumerate(Amiga.models):
if config["id"] == model_id:
self.sub_model_ids.append("")
self.sub_model_titles.append(config["subtitle"])
elif config["id"].startswith(model_id_s):
self.sub_model_ids.append(config["id"].split("/", 1)[1])
self.sub_model_titles.append(config["subtitle"])
else:
continue
if sub_model_id == self.sub_model_ids[-1]:
sub_model_index = len(self.sub_model_ids) - 1
self.sub_model_choice.clear()
for title in self.sub_model_titles:
self.sub_model_choice.add_item(title)
self.sub_model_choice.enable(
LauncherConfig.get(Option.PLATFORM) in AMIGA_PLATFORMS
and len(self.sub_model_ids) > 1)
return sub_model_index
def update_sub_models(self, model_id, sub_model_id):
sub_model_index = 0
model_id_s = model_id + "/"
self.sub_model_ids.clear()
self.sub_model_titles.clear()
for i, config in enumerate(Amiga.models):
if config["id"] == model_id:
self.sub_model_ids.append("")
self.sub_model_titles.append(config["subtitle"])
elif config["id"].startswith(model_id_s):
self.sub_model_ids.append(config["id"].split("/", 1)[1])
self.sub_model_titles.append(config["subtitle"])
else:
continue
if sub_model_id == self.sub_model_ids[-1]:
sub_model_index = len(self.sub_model_ids) - 1
self.sub_model_choice.clear()
for title in self.sub_model_titles:
self.sub_model_choice.add_item(title)
self.sub_model_choice.enable(
LauncherConfig.get(Option.PLATFORM) in AMIGA_PLATFORMS
and len(self.sub_model_ids) > 1
)
return sub_model_index
def update_default_device(self, had_default=None):
config = {}
for port in range(4):
key = "joystick_port_{0}".format(port)
if self.port == port:
config[key] = ""
else:
config[key] = LauncherConfig.get(key)
key = "joystick_port_{0}_mode".format(port)
config[key] = DeviceManager.get_calculated_port_mode(
LauncherConfig, port)
device = DeviceManager.get_device_for_port(config, self.port)
default_description = gettext("Default ({0})").format(
fix_device_name(device.name))
# print("default_description = ", default_description)
if had_default is None:
had_default = (self.device_choice.get_index() == 0)
# print("had default", had_default, self.device_choice.get_index())
self.device_choice.set_item_text(0, default_description)
# print("had_default", had_default)
if had_default:
# print("set text for", self.port, default_description)
# self.device_choice.set_index(1)
self.device_choice.set_text(default_description)
self.device_choice.set_index(0)
def on_browse_button(self, extended=False):
default_dir = FSGSDirectories.get_kickstarts_dir()
if extended:
title = gettext("Choose Extended ROM")
key = "kickstart_ext_file"
else:
title = gettext("Choose Kickstart ROM")
key = "kickstart_file"
dialog = LauncherFilePicker(self.get_window(), title, "rom",
LauncherConfig.get(key))
if not dialog.show_modal():
return
path = dialog.get_path()
checksum_tool = ChecksumTool(self.get_window())
sha1 = checksum_tool.checksum_rom(path)
dir_path, file = os.path.split(path)
if extended:
self.ext_text_field.set_text(file)
else:
self.text_field.set_text(file)
if os.path.normcase(os.path.normpath(dir_path)) == \
os.path.normcase(os.path.normpath(default_dir)):
path = file
if extended:
LauncherConfig.set_multiple([("kickstart_ext_file", path),
("x_kickstart_ext_file", path),
("x_kickstart_ext_file_sha1", sha1)])
else:
LauncherConfig.set_multiple([("kickstart_file", path),
("x_kickstart_file", path),
("x_kickstart_file_sha1", sha1)])
def start_local_game_other(cls):
database_name = LauncherConfig.get("__database")
variant_uuid = LauncherConfig.get("variant_uuid")
assert variant_uuid
fsgs.game.set_from_variant_uuid(database_name, variant_uuid)
platform_handler = PlatformHandler.create(fsgs.game.platform.id)
runner = platform_handler.get_runner(fsgs)
task = RunnerTask(runner)
from .ui.launcher_window import LauncherWindow
dialog = LaunchDialog(
LauncherWindow.current(), gettext("Launching Game"), task)
dialog.show()
LauncherConfig.set("__running", "1")
task.start()
def new_config():
if openretro or settings.get(Option.PLATFORMS_FEATURE):
platform_id = LauncherConfig.get(Option.PLATFORM)
else:
platform_id = None
LauncherConfig.load_default_config(platform=platform_id)
# Settings.set("config_changed", "1")
LauncherSettings.set("parent_uuid", "")
def __init__(self, parent):
StatusElement.__init__(self, parent)
# self.set_min_width(140)
self.layout = HorizontalLayout()
self.icon = Image("launcher:res/16/world_link.png")
self.right_icon = Image("launcher:res/16/drop_down_arrow.png")
self.right_icon_disabled = Image(
"launcher:res/16/drop_down_arrow_disabled.png")
# self.inactive_icon = self.active_icon.grey_scale()
self.text = gettext("Web Links")
LauncherConfig.add_listener(self)
self.on_config("protection", LauncherConfig.get("protection"))
self.have = set()
for key in url_keys:
self.on_config(key, LauncherConfig.get(key))
def __init__(self, parent, platforms):
self.platforms = set(platforms)
parent.__platform_behavior = self
self._parent = weakref.ref(parent)
self.on_config("platform", LauncherConfig.get("platform"))
LauncherConfig.add_listener(self)
# FIXME: We need to disconnect the listener
parent.destroyed.connect(self.on_destroy)
def __init__(self, parent):
StatusElement.__init__(self, parent)
# self.set_min_width(140)
self.layout = HorizontalLayout()
self.icon = Image("launcher:res/16x16/world_link.png")
self.right_icon = Image("launcher:res/16x16/drop_down_arrow.png")
self.right_icon_disabled = Image(
"launcher:res/16x16/drop_down_arrow_disabled.png")
# self.inactive_icon = self.active_icon.grey_scale()
self.text = gettext("Web Links")
LauncherConfig.add_listener(self)
self.on_config("protection", LauncherConfig.get("protection"))
self.have = set()
for key in url_keys:
self.on_config(key, LauncherConfig.get(key))
def on_left_down(self):
if len(self.have) == 0:
return
menu = Menu()
for key, description in url_descriptions:
value = LauncherConfig.get(key, "")
if value:
menu.add_item(description, create_open_url_function(value))
self.popup_menu(menu)
def on_left_down(self):
if len(self.have) == 0:
return
menu = Menu()
for key, description in url_descriptions:
value = LauncherConfig.get(key, "")
if value:
menu.add_item(description, create_open_url_function(value))
self.popup_menu(menu)
def start_local_game_other(cls):
if True:
platform_id = LauncherConfig.get(Option.PLATFORM).lower()
platform_handler = PlatformHandler.create(platform_id)
else:
database_name = LauncherConfig.get("__database")
variant_uuid = LauncherConfig.get("variant_uuid")
assert variant_uuid
fsgs.game.set_from_variant_uuid(database_name, variant_uuid)
platform_handler = PlatformHandler.create(fsgs.game.platform.id)
runner = platform_handler.get_runner(fsgs)
task = RunnerTask(runner)
from .ui.launcherwindow import LauncherWindow
dialog = LaunchDialog(LauncherWindow.current(),
gettext("Launching Game"), task)
dialog.show()
LauncherConfig.set("__running", "1")
task.start()
def update_environment_with_centering_info(self, env):
# FIXME: does not really belong here (dependency loop)
from launcher.launcher_config import LauncherConfig
from launcher.launcher_settings import LauncherSettings
width = LauncherConfig.get("window_width") or LauncherSettings.get(
"window_width"
)
height = LauncherConfig.get("window_height") or LauncherSettings.get(
"window_height"
)
try:
width = int(width)
except:
width = 960
try:
height = int(height)
except:
height = 540
from launcher.ui.launcherwindow import LauncherWindow
if LauncherWindow.current() is None:
return
main_w, main_h = LauncherWindow.current().get_size()
main_x, main_y = LauncherWindow.current().get_position()
x = main_x + (main_w - width) // 2
y = main_y + (main_h - height) // 2
# FIXME: REMOVE
env["FSGS_WINDOW_X"] = str(x)
env["FSGS_WINDOW_Y"] = str(y)
# FIXME: REMOVE
env["SDL_VIDEO_WINDOW_POS"] = str("{0},{1}".format(x, y))
env["FSGS_WINDOW_POS"] = str("{0},{1}".format(x, y))
env["FSGS_WINDOW_CENTER"] = "{0},{1}".format(
main_x + main_w // 2, main_y + main_h // 2
)
def on_changed(self):
index = self.get_index()
value = self.device_values[index]
if value != "none":
# Reset to default device for other ports using the same device.
for port in range(1, 4 + 1):
if self.port == port:
continue
key = "{}_port_{}".format(self._platform, port)
if LauncherConfig.get(key) == value:
LauncherConfig.set(key, "")
LauncherConfig.set(self.device_option_key, value)
def browse(self, dir_mode):
default_dir = FSGSDirectories.get_hard_drives_dir()
dialog = LauncherFilePicker(
self.get_window(),
gettext("Choose Hard Drive"),
"hd",
LauncherConfig.get(self.config_key),
dir_mode=dir_mode,
)
if not dialog.show_modal():
dialog.destroy()
return
path = dialog.get_path()
dialog.destroy()
checksum_tool = ChecksumTool(self.get_window())
sha1 = ""
if dir_mode:
print("not calculating HD checksums for directories")
else:
size = os.path.getsize(path)
if size < 64 * 1024 * 1024:
sha1 = checksum_tool.checksum(path)
else:
print("not calculating HD checksums HD files > 64MB")
full_path = path
# FIXME: use contract function
dir_path, file = os.path.split(path)
self.text_field.set_text(file)
if os.path.normcase(os.path.normpath(dir_path)) == os.path.normcase(
os.path.normpath(default_dir)
):
path = file
self.text_field.set_text(path)
values = [(self.config_key, path), (self.config_key_sha1, sha1)]
if self.index == 0:
# whdload_args = ""
# dummy, ext = os.path.splitext(path)
# if not dir_mode and ext.lower() in Archive.extensions:
# try:
# whdload_args = self.calculate_whdload_args(full_path)
# except Exception:
# traceback.print_exc()
# values.append(("x_whdload_args", whdload_args))
values.extend(
whdload.generate_config_for_archive(
full_path, model_config=False
).items()
)
LauncherConfig.set_multiple(values)
def on_device_changed(self):
index = self.device_choice.get_index()
value = self.joystick_values[index]
if value != "none":
# Reset to default device for other ports using the same device.
for port in range(4):
if self.port == port:
continue
key = "joystick_port_{0}".format(port)
if LauncherConfig.get(key) == value:
LauncherConfig.set(key, "")
LauncherConfig.set(self.device_option_key, value)
def __init__(self, parent, names):
parent.__config_enable_behavior = self
self._parent = weakref.ref(parent)
self._names = set(names)
LauncherConfig.add_listener(self)
try:
parent.destroyed.connect(self.on_parent_destroyed)
except AttributeError:
print("WARNING: ConfigBehavior without remove_listener "
"implementation")
for name in names:
# Broadcast initial value
self.on_config(name, LauncherConfig.get(name))
def __init__(self, parent, names):
parent.__config_enable_behavior = self
self._parent = weakref.ref(parent)
self._names = set(names)
LauncherConfig.add_listener(self)
try:
parent.destroyed.connect(self.on_parent_destroyed)
except AttributeError:
print("WARNING: ConfigBehavior without remove_listener "
"implementation")
for name in names:
# Broadcast initial value
self.on_config(name, LauncherConfig.get(name))
def browse(self, dir_mode):
default_dir = FSGSDirectories.get_hard_drives_dir()
dialog = LauncherFilePicker(
self.get_window(),
gettext("Choose Hard Drive"),
"hd",
LauncherConfig.get(self.config_key),
dir_mode=dir_mode,
)
if not dialog.show_modal():
dialog.destroy()
return
path = dialog.get_path()
dialog.destroy()
checksum_tool = ChecksumTool(self.get_window())
sha1 = ""
if dir_mode:
print("not calculating HD checksums for directories")
else:
size = os.path.getsize(path)
if size < 64 * 1024 * 1024:
sha1 = checksum_tool.checksum(path)
else:
print("not calculating HD checksums HD files > 64MB")
full_path = path
# FIXME: use contract function
dir_path, file = os.path.split(path)
self.text_field.set_text(file)
if os.path.normcase(os.path.normpath(dir_path)) == os.path.normcase(
os.path.normpath(default_dir)):
path = file
self.text_field.set_text(path)
values = [(self.config_key, path), (self.config_key_sha1, sha1)]
if self.index == 0:
# whdload_args = ""
# dummy, ext = os.path.splitext(path)
# if not dir_mode and ext.lower() in Archive.extensions:
# try:
# whdload_args = self.calculate_whdload_args(full_path)
# except Exception:
# traceback.print_exc()
# values.append(("x_whdload_args", whdload_args))
values.extend(
whdload.generate_config_for_archive(
full_path, model_config=False).items())
LauncherConfig.set_multiple(values)
def on_config(self, key, value):
if key == "platform":
self.layout.update()
return
if key == "amiga_model":
value = LauncherConfig.get("joystick_port_{0}_mode".format(
self.port))
self.set_value_or_default(value)
if key == self.mode_option_key or key == "amiga_model":
value = DeviceManager.get_calculated_port_mode(
LauncherConfig, self.port)
for i, config in enumerate(self.joystick_mode_values):
if config == value:
if self.mode_choice is not None:
self.mode_choice.set_index(i)
if self.port >= 4:
self.device_choice.enable(i != 0)
break
else:
print("FIXME: could not set mode")
elif key == self.device_option_key or key == "amiga_model":
# print(self.joystick_values)
value_lower = value.lower()
for i, name in enumerate(self.joystick_values):
if value_lower == name.lower():
self.device_choice.set_index(i)
break
elif key == self.autofire_mode_option_key:
if self.autofire_button is not None:
if value == "1":
self.autofire_button.set_tooltip(
gettext("Auto-Fire is On"))
self.autofire_button.set_icon_name(
"16x16/lightning_red.png")
else:
self.autofire_button.set_tooltip(
gettext("Auto-Fire is Off"))
self.autofire_button.set_icon_name(
"16x16/lightning_off.png")
# this is intended to catch all config changes for all ports (both
# mode and device) to update the defaults
if key.startswith("joystick_port_") or key == "amiga_model":
self.update_default_device()
def on_browse_button(self, extended=False):
default_dir = FSGSDirectories.get_kickstarts_dir()
if extended:
title = gettext("Choose Extended ROM")
key = "kickstart_ext_file"
else:
title = gettext("Choose Kickstart ROM")
key = "kickstart_file"
dialog = LauncherFilePicker(
self.get_window(), title, "rom", LauncherConfig.get(key)
)
if not dialog.show_modal():
return
path = dialog.get_path()
checksum_tool = ChecksumTool(self.get_window())
sha1 = checksum_tool.checksum_rom(path)
dir_path, file = os.path.split(path)
if extended:
self.ext_text_field.set_text(file)
else:
self.text_field.set_text(file)
if os.path.normcase(os.path.normpath(dir_path)) == os.path.normcase(
os.path.normpath(default_dir)
):
path = file
if extended:
LauncherConfig.set_multiple(
[
("kickstart_ext_file", path),
("x_kickstart_ext_file", path),
("x_kickstart_ext_file_sha1", sha1),
]
)
else:
LauncherConfig.set_multiple(
[
("kickstart_file", path),
("x_kickstart_file", path),
("x_kickstart_file_sha1", sha1),
]
)
def __init__(self, parent, fsgc, port_gui_index):
super().__init__(parent, [""], read_only=True)
self.fsgc = fsgc
self.port_gui_index = port_gui_index
self.port = self.port_gui_index + 1
self._platform = ""
self._config_key = ""
self.device_option_key = ""
# AmigaEnableBehavior(self.device_choice)
self.device_values = []
self.rebuild_device_list()
self.fsgc.signal.connect("config", self.on_config)
# Must check platform before device option key
self.on_config(Option.PLATFORM, self.fsgc.config.get(Option.PLATFORM))
self.on_config(self.device_option_key,
LauncherConfig.get(self.device_option_key))
# self.changed.connect(self.__changed)
self.set_index(0)
LauncherConfig.add_listener(self)
LauncherSignal.add_listener("settings_updated", self)
LauncherSignal.add_listener("device_list_updated", self)
def save_config():
print("SaveButton.save_config")
database = Database.get_instance()
name = LauncherSettings.get("config_name").strip()
if not name:
print("no config_name")
# FIXME: notify user
return
file_name = name + ".fs-uae"
path = os.path.join(FSGSDirectories.get_configurations_dir(),
file_name)
with io.open(path, "w", encoding="UTF-8") as f:
f.write("# FS-UAE configuration saved by FS-UAE Launcher\n")
f.write("# Last saved: {0}\n".format(
datetime.datetime.today().strftime("%Y-%m-%d %H:%M:%S")))
f.write("\n[fs-uae]\n")
keys = sorted(fsgs.config.values.keys())
for key in keys:
value = LauncherConfig.get(key)
if key.startswith("__"):
continue
if key in LauncherConfig.no_save_keys_set:
continue
# elif key == "joystick_port_2_mode" and value == "nothing":
# continue
# elif key == "joystick_port_3_mode" and value == "nothing":
# continue
if value == LauncherConfig.default_config.get(key, ""):
continue
if value:
f.write("{0} = {1}\n".format(key, value))
# scanner = ConfigurationScanner()
# search = ConfigurationScanner.create_configuration_search(name)
# name = scanner.create_configuration_name(name)
# print("adding", path)
# # deleting the path from the database first in case it already exists
# database.delete_configuration(path=path)
# database.delete_file(path=path)
# database.add_file(path=path)
# database.add_configuration(
# path=path, uuid="", name=name, scan=0, search=search)
file_database = FileDatabase.get_instance()
scanner = ConfigurationScanner()
print("[save config] adding config", path)
file_database.delete_file(path=path)
with open(path, "rb") as f:
sha1 = hashlib.sha1(f.read()).hexdigest()
file_database.add_file(path=path, sha1=sha1)
game_id = database.add_configuration(
path=path, name=scanner.create_configuration_name(name))
database.update_game_search_terms(game_id,
scanner.create_search_terms(name))
database.commit()
file_database.commit()
LauncherSettings.set("__config_refresh", str(time.time()))
# Settings.set("config_changed", "0")
LauncherConfig.set("__changed", "0")
def get(key):
return LauncherConfig.get(key)
def create_option_group(
parent, options, option, key, option_type, option_text,
use_checkbox, use_help_button, label_spacing):
group = fsui.Group(parent)
group.layout = fsui.HorizontalLayout()
if use_checkbox:
group.layout.add(
OptionCheckBox(group, option_text + ":", options, key),
margin_right=label_spacing)
else:
group.layout.add(
fsui.Label(group, option_text + ":"),
margin_right=label_spacing)
choice_values = []
if option_type == "boolean":
group.layout.add_spacer(0, expand=True)
group.layout.add(BooleanChoiceControl(
group, options, key, use_checkbox=use_checkbox))
elif option_type == "choice":
group.layout.add_spacer(0, expand=True)
choices = option["values"]
# if use_checkbox:
# choices,insert(("", gettext("Auto")))
group.layout.add(ChoiceControl(
group, options, key, choices, use_checkbox=use_checkbox))
elif option_type == "string":
def on_changed():
val = text_field.get_text()
LauncherConfig.set(key, val.strip())
text_field = fsui.TextField(group)
# text_field.set_min_width(400)
text_field.set_text(LauncherConfig.get(key))
text_field.on_changed = on_changed
group.layout.add(text_field, expand=True)
elif option["type"].lower() == "integer" and "min" in option \
and "max" in option:
assert use_checkbox
spin_ctrl = SpinValueControl(
group, options, key, option["min"], option["max"])
# current = LauncherConfig.get(key)
# current_int = int(option["default"])
# if current:
# try:
# current_int = int(current)
# except ValueError:
# pass
# current_int = max(option["min"], min(option["max"], current_int))
# check_box = fsui.CheckBox(group, gettext("Default"))
# spin_ctrl = fsui.SpinCtrl(group, option["min"],
# option["max"], current_int)
# if current == "":
# check_box.check()
# spin_ctrl.disable()
# def on_checkbox():
# if check_box.is_checked():
# spin_ctrl.set_value(int(option["default"]))
# spin_ctrl.disable()
# LauncherConfig.set(key, "")
# else:
# spin_ctrl.enable()
#
# check_box.on_changed = on_checkbox
#
# def on_spin():
# val = spin_ctrl.get_value()
# val = max(option["min"], min(option["max"], val))
# LauncherConfig.set(key, str(val))
# spin_ctrl.on_changed = on_spin
# group.layout.add(check_box)
group.layout.add_spacer(0, expand=True)
group.layout.add(spin_ctrl, margin_left=10)
if choice_values:
def on_changed():
index = choice.get_index()
LauncherConfig.set(key, choice_values[index][0])
choice_labels = [x[1] for x in choice_values]
choice = fsui.Choice(group, choice_labels)
current = LauncherConfig.get(key)
for i, value in enumerate(choice_values):
if current == value[0]:
choice.set_index(i)
break
choice.on_changed = on_changed
group.layout.add_spacer(0, expand=True)
group.layout.add(choice)
group.widget = choice
if use_help_button:
help_button = HelpButton(
parent, "https://fs-uae.net/options#" + key)
group.layout.add(help_button, margin_left=10)
return group
def __init__(self, parent):
super().__init__(parent, "save_button.png")
self.set_tooltip(gettext("Save Config"))
LauncherConfig.add_listener(self)
self.on_config("__changed", LauncherConfig.get("__changed"))
def on_platform_settings_button(self):
platform = LauncherConfig.get("platform")
if platform:
PlatformSettingsDialog.open(self.window, platform)
def on_platform_settings_button(self):
platform = LauncherConfig.get("platform")
if platform:
PlatformSettingsDialog.open(self.window, platform)
def start_local_game_amiga(cls):
# make sure x_kickstart_file is initialized
LauncherConfig.set_kickstart_from_model()
# if not Config.get("x_kickstart_file"): # or not \
# # os.path.exists(Config.get("kickstart_file")):
# fsui.show_error(
# gettext("No kickstart found for this model. Use the 'Import "
# "Kickstarts' function from the menu."))
# return
cs = Amiga.get_model_config(
LauncherConfig.get("amiga_model"))["ext_roms"]
if len(cs) > 0:
# extended kickstart ROM is needed
if not LauncherConfig.get("x_kickstart_ext_file"):
fsui.show_error(
gettext("No extended kickstart found for this model. "
"Try 'scan' function."))
return
config = LauncherConfig.copy()
prepared_config = cls.prepare_config(config)
model = LauncherConfig.get("amiga_model")
if model.startswith("CD32"):
platform = "CD32"
elif model == "CDTV":
platform = "CDTV"
else:
platform = "Amiga"
name = LauncherSettings.get("config_name")
uuid = LauncherConfig.get("x_game_uuid")
from fsgs.SaveStateHandler import SaveStateHandler
save_state_handler = SaveStateHandler(fsgs, name, platform, uuid)
from fsgs.amiga.LaunchHandler import LaunchHandler
launch_handler = LaunchHandler(fsgs, name, prepared_config,
save_state_handler)
from .ui.launcher_window import LauncherWindow
task = AmigaLaunchTask(launch_handler)
# dialog = LaunchDialog(MainWindow.instance, launch_handler)
dialog = LaunchDialog(
LauncherWindow.current(), gettext("Launching FS-UAE"), task)
dialog.show()
def on_show_license_information(license_text):
unused(license_text)
# FIXME: don't depend on wx here
# noinspection PyUnresolvedReferences
# import wx
# license_dialog = wx.MessageDialog(
# dialog, license_text, _("Terms of Use"),
# wx.OK | wx.CANCEL | wx.CENTRE)
# license_dialog.CenterOnParent()
# result = license_dialog.ShowModal()
# return result == wx.ID_OK
# FIXME
return True
fsgs.file.on_show_license_information = on_show_license_information
LauncherConfig.set("__running", "1")
task.start()
def save_config():
print("SaveButton.save_config")
database = Database.get_instance()
name = LauncherSettings.get("config_name").strip()
if not name:
print("no config_name")
# FIXME: notify user
return
file_name = name + ".fs-uae"
path = os.path.join(
FSGSDirectories.get_configurations_dir(), file_name)
with io.open(path, "w", encoding="UTF-8") as f:
f.write("# FS-UAE configuration saved by FS-UAE Launcher\n")
f.write("# Last saved: {0}\n".format(
datetime.datetime.today().strftime("%Y-%m-%d %H:%M:%S")))
f.write("\n[fs-uae]\n")
keys = sorted(fsgs.config.values.keys())
for key in keys:
value = LauncherConfig.get(key)
if key.startswith("__"):
continue
if key in LauncherConfig.no_save_keys_set:
continue
# elif key == "joystick_port_2_mode" and value == "nothing":
# continue
# elif key == "joystick_port_3_mode" and value == "nothing":
# continue
if value == LauncherConfig.default_config.get(key, ""):
continue
if value:
f.write("{0} = {1}\n".format(key, value))
# scanner = ConfigurationScanner()
# search = ConfigurationScanner.create_configuration_search(name)
# name = scanner.create_configuration_name(name)
# print("adding", path)
# # deleting the path from the database first in case it already exists
# database.delete_configuration(path=path)
# database.delete_file(path=path)
# database.add_file(path=path)
# database.add_configuration(
# path=path, uuid="", name=name, scan=0, search=search)
file_database = FileDatabase.get_instance()
scanner = ConfigurationScanner()
print("[save config] adding config", path)
file_database.delete_file(path=path)
with open(path, "rb") as f:
sha1 = hashlib.sha1(f.read()).hexdigest()
file_database.add_file(path=path, sha1=sha1)
game_id = database.add_game(
path=path, name=scanner.create_configuration_name(name))
database.update_game_search_terms(
game_id, scanner.create_search_terms(name))
database.commit()
file_database.commit()
LauncherSettings.set("__config_refresh", str(time.time()))
# Settings.set("config_changed", "0")
LauncherConfig.set("__changed", "0")
def initialize_from_config(self):
self.on_config("kickstart_file", LauncherConfig.get("kickstart_file"))
self.on_config(
"kickstart_ext_file", LauncherConfig.get("kickstart_ext_file")
)
def on_changed(self):
variant_uuid = LauncherConfig.get("variant_uuid", "")
if not variant_uuid:
return
rating = self.index_to_rating(self.get_index())
self.set_rating_for_variant(variant_uuid, rating)
def initialize_from_config(self):
self.on_config(self.config_key, LauncherConfig.get(self.config_key))
def initialize_from_config(self):
self.on_config(self.config_key, LauncherConfig.get(self.config_key))
