def on_destroy(self):
# fsgs.signal.disconnect(
# "fsgs:config:floppy_drive_{0}".format(self.drive),
# self.on_config_floppy_drive)
# fsgs.signal.disconnect("config", self.on_config)
get_config(self).detach(self.__on_config)
super().on_destroy()
def set_config_handlers(self):
if self.mode_choice is not None:
self.mode_choice.on_changed = self.on_mode_changed
self.device_choice.on_changed = self.on_device_changed
get_config(self).add_listener(self)
LauncherSignal.add_listener("settings_updated", self)
LauncherSignal.add_listener("device_list_updated", self)
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] = get_config(self).get(key)
key = "joystick_port_{0}_mode".format(port)
config[key] = DeviceManager.get_calculated_port_mode(
get_config(self), 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.index() == 0
# print("had default", had_default, self.device_choice.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 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] = get_config(self).get(key)
key = "{}_port_{}_type".format(self._platform, port)
config[key] = get_config(self).get(key)
# config[key] = DeviceManager.get_calculated_port_mode(
# get_config(self), 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.index() == 0
# print("had default", had_default, self.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 initialize_from_config(self):
self.on_config(
self.device_option_key,
get_config(self).get(self.device_option_key),
)
self.on_config(self.mode_option_key,
get_config(self).get(self.mode_option_key))
self.on_config(
self.autofire_mode_option_key,
get_config(self).get(self.autofire_mode_option_key),
)
def on_changed(self):
index = self.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 get_config(self).get(key) == value:
get_config(self).set(key, "")
get_config(self).set(self.device_option_key, value)
def on_device_changed(self):
index = self.device_choice.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 get_config(self).get(key) == value:
get_config(self).set(key, "")
get_config(self).set(self.device_option_key, value)
def load_configuration(self, item):
if item[str("uuid")]:
# This triggers the variant browser to load variants for the game.
# FIXME: This needs to be moved to config, somehow.
get_config(self).set(PARENT_UUID, item["uuid"])
# FIXME: REMOVE
# LauncherSettings.set(PARENT_UUID, item["uuid"])
else:
config_path = Database.get_instance().decode_path(
item[str("path")])
print("load config from", config_path)
ConfigLoader(get_config(self)).load_config_file(config_path)
def browse(self, dir_mode):
default_dir = FSGSDirectories.get_hard_drives_dir()
dialog = LauncherFilePicker(
self.get_window(),
gettext("Choose Hard Drive"),
"hd",
get_config(self).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())
get_config(self).set_multiple(values)
def __init__(self, parent, names):
parent.__config_enable_behavior = self
self._parent = weakref.ref(parent)
self._names = set(names)
get_config(parent).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, get_config(parent).get(name))
def on_accuracy_changed(self):
index = self.accuracy_choice.index()
config = get_config(self)
if index == 0:
config.set("accuracy", "")
else:
config.set("accuracy", str(1 - 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 config in 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()
config = get_config(self)
for title in self.sub_model_titles:
self.sub_model_choice.add_item(title)
self.sub_model_choice.set_enabled(
config.get(Option.PLATFORM) in AMIGA_PLATFORMS
and len(self.sub_model_ids) > 1)
return sub_model_index
def on_variant_rating_config(self, event):
variant_uuid = get_config(self).get(VARIANT_UUID__)
for item in self.items:
if item["uuid"] == variant_uuid:
item["personal_rating"] = int(event.value or 0)
self.update()
break
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,
get_config(self).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 __init__(self, parent, port_gui_index):
super().__init__(parent, [""], read_only=True)
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()
config = get_config(self)
# Must check platform before device option key
self.on_config(Option.PLATFORM, config.get(Option.PLATFORM))
self.on_config(
self.device_option_key,
config.get(self.device_option_key),
)
# self.changed.connect(self.__changed)
self.set_index(0)
config.add_listener(self)
LauncherSignal.add_listener("settings_updated", self)
LauncherSignal.add_listener("device_list_updated", self)
def set_value_or_default(self, value):
if self.port == 0:
if value == "mouse":
value = ""
elif self.port == 1:
if get_config(self).get("amiga_model").startswith("CD32"):
default = "cd32 gamepad"
else:
default = "joystick"
if value == default:
value = ""
else:
if value == "nothing":
value = ""
if get_config(self).get(self.mode_option_key) != value:
get_config(self).set(self.mode_option_key, value)
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)
config = get_config(self)
self.on_config(self.config_key, config.get(self.config_key))
self.on_config(
self.config_key_implicit,
config.get(self.config_key_implicit),
)
def on_amiga_model_config(self, value):
config = get_config(self)
config.update_kickstart()
if value != self.amiga_model:
self.amiga_model = value
self.amiga_model_calculated = value.split("/")[0]
self.rebuild_warnings_and_refresh()
def on_activate_item(self, item):
config = get_config(self)
path = config.get(self.file_key.format(item))
sha1 = config.get(self.sha1_key.format(item))
if self.cd_mode:
pass
else:
fsgs.amiga.insert_floppy_in_free_drive(path, sha1=sha1)
def on_config(self, key, value):
if key == "platform":
self.layout.update()
return
if key == "amiga_model":
value = get_config(self).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(
get_config(self), 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.set_enabled(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 get_url(self):
config = get_config(self)
variant_uuid = config.get("variant_uuid", "")
if not variant_uuid:
return
return "{0}/game/{1}/edit#{1}".format(
openretro_url_prefix(), variant_uuid
)
def on_eject(self):
config = get_config(self)
if self.mode == self.CD_MODE:
CDManager.eject(self.drive, config=config)
elif self.mode == self.FLOPPY_MODE:
FloppyManager.eject(self.drive, config=config)
else:
fsgs.config.set(self.config_key, "")
def function():
if progress == "__run__":
self.cancel_button.set_enabled(False)
# Hide dialog after 1.5 seconds. The reason for delaying it
# is to avoid "confusing" flickering if/when the dialog is
# only shown for a split second.
if self.visible():
fsui.call_later(1500, hide_function)
get_config(self).set("__progress",
gettext("Running: Emulator"))
else:
if self.no_gui:
print("[PROGRESS]", progress)
else:
self.sub_title_label.set_text(progress)
get_config(self).set("__progress",
"Preparing: {}".format(progress))
def set_rating_for_variant(self, variant_uuid, rating):
# FIXME: Do asynchronously, add to queue
client = OGDClient()
result = client.rate_variant(variant_uuid, like=rating)
like_rating = result.get("like", 0)
work_rating = result.get("work", 0)
database = Database.instance()
cursor = database.cursor()
cursor.execute("DELETE FROM rating WHERE game_uuid = ?",
(variant_uuid, ))
cursor.execute(
"INSERT INTO rating (game_uuid, work_rating, like_rating) "
"VALUES (?, ?, ?)",
(variant_uuid, work_rating, like_rating),
)
database.commit()
# LauncherSettings.set("__variant_rating", str(like_rating))
get_config(self).set(VARIANT_RATING__, str(like_rating))
def __init__(self, parent, platforms):
self._widget = parent
self.platforms = set(platforms)
# self._parent = weakref.ref(parent)
parent.__platform_behavior = self
config = get_config(self.widget())
self.on_config("platform", config.get("platform"))
config.add_listener(self)
parent.destroyed.connect(self.__on_parent_destroy)
def on_model_changed(self):
print("ModelGroup.on_model_change\n")
index = self.model_choice.index()
model = self.model_ids[index]
if model == "A500":
# The default model (A500) can be specified with the empty string
model = ""
config = get_config(self)
config.set("amiga_model", model)
def on_left_down(self):
config = get_config(self)
if len(self.have) == 0:
return
menu = Menu()
for key, description in url_descriptions:
value = config.get(key, "")
if value:
menu.add_item(description, create_open_url_function(value))
self.popup_menu(menu)
def __init__(self, parent, icon=None):
if icon is not None:
self.icon = icon
else:
self.icon = Image("launcher:/data/16x16/world.png")
Panel.__init__(self, parent, paintable=True)
# self.set_tooltip(tooltip)
config = get_config(self)
config.add_listener(self)
self.on_config("variant_uuid", "")
def update_media_type(self):
if self.__platform in AMIGA_PLATFORMS:
self.set_cd_mode(Amiga.is_cd_based(get_config(self)))
elif self.__platform in [Platform.C64]:
if self._c64_model == C64_MODEL_C64C_1541_II:
self.set_mode(self.FLOPPY_MODE)
else:
self.set_mode(self.TAPE_MODE)
elif self.__platform in [Platform.CPC]:
if self._cpc_model == CPC_MODEL_464:
self.set_mode(self.TAPE_MODE)
else:
self.set_mode(self.FLOPPY_MODE)
elif self.__platform in [Platform.DOS]:
self.set_mode(self.FLOPPY_MODE)
elif self.__platform in [Platform.PSX]:
self.set_mode(self.CD_MODE)
elif self.__platform in [Platform.ST]:
self.set_mode(self.FLOPPY_MODE)
elif self.__platform in [Platform.SPECTRUM]:
if self._spectrum_model == SPECTRUM_MODEL_PLUS3:
self.set_mode(self.FLOPPY_MODE)
else:
self.set_mode(self.TAPE_MODE)
else:
self.set_mode(self.CARTRIDGE_MODE)
if self._main:
if self.__platform == Platform.A7800:
self.selectors[1].hide()
self._a78_header_widget.show()
self._command_widget.hide()
self._ines_header_widget.hide()
elif self.__platform in [
Platform.CPC,
Platform.DOS,
Platform.SPECTRUM,
]:
self.selectors[1].hide()
self._a78_header_widget.hide()
self._command_widget.show()
self._ines_header_widget.hide()
elif self.__platform == Platform.NES:
# if self.selectors[1].is_visible():
self.selectors[1].hide()
self._a78_header_widget.hide()
self._command_widget.hide()
self._ines_header_widget.show()
else:
# if not self.selectors[1].is_visible():
self.selectors[1].show()
self._command_widget.hide()
self._a78_header_widget.hide()
self._ines_header_widget.hide()
self.layout.update()
def __init__(self, parent):
StatusElement.__init__(self, parent)
self.icon = Image("launcher:/data/16x16/user.png")
self.text = gettext("N/A")
self.active = False
self.players = ""
config = get_config(self)
config.add_listener(self)
self.on_config("players", config.get("players"))
