def multi_select(cls, parent=None):
default_dir = FSGSDirectories.get_floppies_dir()
dialog = LauncherFilePicker(parent,
gettext("Select Multiple Floppies"),
"floppy",
multiple=True)
if not dialog.show_modal():
return
original_paths = dialog.get_paths()
original_paths.sort()
paths = []
for path in original_paths:
path = Paths.get_real_case(path)
embedded_files = []
if path.endswith(".zip"):
archive = Archive(path)
files = archive.list_files()
for file in files:
name, ext = os.path.splitext(file)
# FIXME: get list of floppy extensions from a central
# place
if ext in [".adf", ".ipf"]:
embedded_files.append(file)
if len(embedded_files) > 0:
embedded_files.sort()
print("found embedded floppy images:")
print(embedded_files)
for file in embedded_files:
paths.append(file)
else:
paths.append(path)
checksum_tool = ChecksumTool(parent)
for i, path in enumerate(paths):
sha1 = checksum_tool.checksum(path)
path = Paths.contract_path(path,
default_dir,
force_real_case=False)
if i < 4:
LauncherConfig.set_multiple([
("floppy_drive_{0}".format(i), path),
("x_floppy_drive_{0}_sha1".format(i), sha1)
])
LauncherConfig.set_multiple([("floppy_image_{0}".format(i), path),
("x_floppy_image_{0}_sha1".format(i),
sha1)])
# blank the rest of the drives
for i in range(len(paths), 4):
LauncherConfig.set_multiple([("floppy_drive_{0}".format(i), ""),
("x_floppy_drive_{0}_sha1".format(i),
"")])
# blank the rest of the image list
for i in range(len(paths), 20):
LauncherConfig.set_multiple([("floppy_image_{0}".format(i), ""),
("x_floppy_image_{0}_sha1".format(i),
"")])
def multiselect(cls, parent=None):
default_dir = FSGSDirectories.get_floppies_dir()
dialog = LauncherFilePicker(
parent, gettext("Select Multiple Floppies"),
"floppy", multiple=True)
if not dialog.show_modal():
return
original_paths = dialog.get_paths()
original_paths.sort()
paths = []
for path in original_paths:
path = Paths.get_real_case(path)
embedded_files = []
if path.endswith(".zip"):
archive = Archive(path)
files = archive.list_files()
for file in files:
name, ext = os.path.splitext(file)
# FIXME: get list of floppy extensions from a central
# place
if ext in [".adf", ".ipf"]:
embedded_files.append(file)
if len(embedded_files) > 0:
embedded_files.sort()
print("found embedded floppy images:")
print(embedded_files)
for file in embedded_files:
paths.append(file)
else:
paths.append(path)
checksum_tool = ChecksumTool(parent)
for i, path in enumerate(paths):
sha1 = checksum_tool.checksum(path)
path = Paths.contract_path(
path, default_dir, force_real_case=False)
if i < 4:
LauncherConfig.set_multiple([
("floppy_drive_{0}".format(i), path),
("x_floppy_drive_{0}_sha1".format(i), sha1)])
LauncherConfig.set_multiple([
("floppy_image_{0}".format(i), path),
("x_floppy_image_{0}_sha1".format(i), sha1)])
# blank the rest of the drives
for i in range(len(paths), 4):
LauncherConfig.set_multiple([
("floppy_drive_{0}".format(i), ""),
("x_floppy_drive_{0}_sha1".format(i), "")])
# blank the rest of the image list
for i in range(len(paths), 20):
LauncherConfig.set_multiple([
("floppy_image_{0}".format(i), ""),
("x_floppy_image_{0}_sha1".format(i), "")])
def get_whdload_dir(cls):
cls._initialize()
path = os.path.join(cls.get_hard_drives_dir(), "WHDLoad")
if os.path.exists(path):
path = Paths.get_real_case(path)
return path
return None
def insert_floppy(self, drive, path, sha1=None):
if sha1 is None:
sha1 = ChecksumTool().checksum(path)
default_dir = FSGSDirectories.get_floppies_dir()
path = Paths.contract_path(path, default_dir)
self.set_config([("floppy_drive_{0}".format(drive), path),
("x_floppy_drive_{0}_sha1".format(drive), sha1)])
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 on_add_button(self):
existing_items = self.create_list()
default_dir = FSGSDirectories.get_floppies_dir()
if self.cd_mode:
dialog = LauncherFilePicker(
self.get_window(), gettext("Select Multiple CD-ROMs"),
"cd", multiple=True)
else:
dialog = LauncherFilePicker(
self.get_window(), gettext("Select Multiple Floppies"),
"floppy", multiple=True)
if not dialog.show_modal():
print("dialog.show returned false")
return
print("dialog.show returned true")
paths = dialog.get_paths()
paths.sort()
print(paths)
checksum_tool = ChecksumTool(self.get_window())
for i, path in enumerate(paths):
sha1 = checksum_tool.checksum(path)
path = Paths.contract_path(path, default_dir)
dir, file = os.path.split(path)
if os.path.normcase(os.path.normpath(dir)) == \
os.path.normcase(os.path.normpath(default_dir)):
path = file
existing_items.append((path, sha1))
self.set_new_config(existing_items)
def unpack_game_hard_drive(self, drive_index, src):
print("unpack_game_hard_drive", drive_index, src)
scheme, dummy, dummy, game_uuid, drive = src.split("/")
drive_prefix = drive + "/"
dir_name = "DH{0}".format(drive_index)
dir_path = os.path.join(self.temp_dir, dir_name)
file_list = self.get_file_list_for_game_uuid(game_uuid)
for file_entry in file_list:
if self.stop_flag:
return
name = file_entry["name"]
if not name.startswith(drive_prefix):
continue
# extract Amiga relative path and convert each path component
# to host file name (where needed).
amiga_rel_path = name[len(drive_prefix):]
print("amiga_rel_path", amiga_rel_path)
amiga_rel_parts = amiga_rel_path.split("/")
for i, part in enumerate(amiga_rel_parts):
# part can be blank if amiga_rel_parts is a directory
# (ending with /)
if part:
amiga_rel_parts[i] = amiga_filename_to_host_filename(part)
amiga_rel_path = "/".join(amiga_rel_parts)
dst_file = os.path.join(dir_path, amiga_rel_path)
print(repr(dst_file))
if name.endswith("/"):
os.makedirs(Paths.str(dst_file))
continue
if not os.path.exists(os.path.dirname(dst_file)):
os.makedirs(os.path.dirname(dst_file))
sha1 = file_entry["sha1"]
# current_task.set_progress(os.path.basename(dst_file))
current_task.set_progress(amiga_rel_path)
self.fsgs.file.copy_game_file("sha1://{0}".format(sha1), dst_file)
# src_file = self.fsgs.file.find_by_sha1(sha1)
# if not os.path.exists(os.path.dirname(dst_file)):
# os.makedirs(os.path.dirname(dst_file))
# stream = self.fsgs.file.open(src_file)
# # archive = Archive(src_file)
# # f = archive.open(src_file)
# data = stream.read()
# assert hashlib.sha1(data).hexdigest() == sha1
# with open(dst_file, "wb") as out_file:
# out_file.write(data)
metadata = ["----rwed", " ", "2000-01-01 00:00:00.00", " ", "",
"\n"]
if "comment" in file_entry:
metadata[4] = self.encode_file_comment(file_entry["comment"])
with open(dst_file + ".uaem", "wb") as out_file:
out_file.write("".join(metadata).encode("UTF-8"))
self.config["hard_drive_{0}".format(drive_index)] = dir_path
def on_add_button(self):
existing_items = self.create_list()
default_dir = FSGSDirectories.get_floppies_dir()
if self.cd_mode:
dialog = LauncherFilePicker(self.get_window(),
gettext("Select Multiple CD-ROMs"),
"cd",
multiple=True)
else:
dialog = LauncherFilePicker(self.get_window(),
gettext("Select Multiple Floppies"),
"floppy",
multiple=True)
if not dialog.show_modal():
print("dialog.show returned false")
return
print("dialog.show returned true")
paths = dialog.get_paths()
paths.sort()
print(paths)
checksum_tool = ChecksumTool(self.get_window())
for i, path in enumerate(paths):
sha1 = checksum_tool.checksum(path)
path = Paths.contract_path(path, default_dir)
dir, file = os.path.split(path)
if os.path.normcase(os.path.normpath(dir)) == \
os.path.normcase(os.path.normpath(default_dir)):
path = file
existing_items.append((path, sha1))
self.set_new_config(existing_items)
def config_startup_scan(cls):
if cls._config_scanned:
return
cls._config_scanned = True
configs_dir = FSGSDirectories.get_configurations_dir()
print("config_startup_scan", configs_dir)
print(LauncherSettings.settings)
settings_mtime = LauncherSettings.get("configurations_dir_mtime")
dir_mtime = cls.get_dir_mtime_str(configs_dir)
if settings_mtime == dir_mtime + "+" + str(Database.VERSION):
print("... mtime not changed", settings_mtime, dir_mtime)
return
database = Database.get_instance()
file_database = FileDatabase.get_instance()
print("... database.find_local_configurations")
local_configs = Database.get_instance().find_local_configurations()
print("... walk configs_dir")
for dir_path, dir_names, file_names in os.walk(configs_dir):
for file_name in file_names:
if not file_name.endswith(".fs-uae"):
continue
path = Paths.join(dir_path, file_name)
if path in local_configs:
local_configs[path] = None
# already exists in database
continue
name, ext = os.path.splitext(file_name)
# search = ConfigurationScanner.create_configuration_search(
# name)
scanner = ConfigurationScanner()
print("[startup] 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)
)
for path, config_id in local_configs.items():
if config_id is not None:
print("[startup] removing configuration", path)
database.delete_game(id=config_id)
file_database.delete_file(path=path)
print("... commit")
database.commit()
LauncherSettings.set(
"configurations_dir_mtime",
cls.get_dir_mtime_str(configs_dir) + "+" + str(Database.VERSION),
)
def insert_cd(self, drive, path, sha1=None):
if sha1 is None:
sha1 = ""
print("FIXME: not calculating CD checksum just yet")
default_dir = FSGSDirectories.get_cdroms_dir()
path = Paths.contract_path(path, default_dir)
self.set_config([("cdrom_drive_{0}".format(drive), path),
("x_cdrom_drive_{0}_sha1".format(drive), sha1)])
def get_kickstarts_dir(cls):
path = cls.portable_dir("kickstarts_dir")
if not path:
path = os.path.join(cls.get_base_dir(), "Kickstarts")
if not os.path.exists(path):
os.makedirs(path)
path = Paths.get_real_case(path)
return path
def get_hard_drives_dir(cls):
path = cls.portable_dir("hard_drives_dir")
if not path:
path = os.path.join(cls.get_base_dir(), "Hard Drives")
if not os.path.exists(path):
os.makedirs(path)
path = Paths.get_real_case(path)
return path
def get_data_dir(cls):
path = cls.portable_dir("data_dir")
if not path:
path = os.path.join(cls.get_base_dir(), "Data")
if not os.path.exists(path):
os.makedirs(path)
path = Paths.get_real_case(path)
return path
def get_logs_dir(cls):
path = cls.portable_dir("logs_dir")
if not path:
path = os.path.join(cls.get_cache_dir(), "Logs")
if not os.path.exists(path):
os.makedirs(path)
path = Paths.get_real_case(path)
return path
def downloads_dir(cls):
path = cls.portable_dir("downloads_dir")
if not path:
path = os.path.join(cls.get_base_dir(), "Downloads")
if not os.path.exists(path):
os.makedirs(path)
path = Paths.get_real_case(path)
return path
def insert_floppy(self, drive, path, sha1=None):
if sha1 is None:
sha1 = ChecksumTool().checksum(path)
default_dir = FSGSDirectories.get_floppies_dir()
path = Paths.contract_path(path, default_dir)
self.set_config([
("floppy_drive_{0}".format(drive), path),
("x_floppy_drive_{0}_sha1".format(drive), sha1)])
def get_save_states_dir(cls):
path = cls.portable_dir("save_states_dir")
if not path:
path = os.path.join(cls.get_base_dir(), "Save States")
if not os.path.exists(path):
os.makedirs(path)
path = Paths.get_real_case(path)
return path
def get_controllers_dir(cls):
path = cls.portable_dir("controllers_dir")
if not path:
path = os.path.join(cls.get_base_dir(), "Controllers")
if not os.path.exists(path):
os.makedirs(path)
path = Paths.get_real_case(path)
return path
def get_floppies_dir(cls):
path = cls.portable_dir("floppies_dir")
if not path:
path = os.path.join(cls.get_base_dir(), "Floppies")
if not os.path.exists(path):
os.makedirs(path)
path = Paths.get_real_case(path)
return path
def insert_multiple_floppies(self, insert_paths):
paths = []
for path in insert_paths:
embedded_files = []
if path.endswith(".zip"):
archive = Archive(path)
files = archive.list_files()
for file in files:
name, ext = os.path.splitext(file)
# FIXME: get list of floppy extensions from a central
# place
if ext in [".adf", ".ipf"]:
embedded_files.append(file)
if len(embedded_files) > 0:
embedded_files.sort()
print("found embedded floppy images:")
print(embedded_files)
for file in embedded_files:
paths.append(file)
else:
paths.append(path)
default_dir = FSGSDirectories.get_floppies_dir()
checksum_tool = ChecksumTool()
for i, path in enumerate(paths):
sha1 = checksum_tool.checksum(path)
path = Paths.contract_path(path, default_dir)
if i < 4:
self.set_config(
[
("floppy_drive_{0}".format(i), path),
("x_floppy_drive_{0}_sha1".format(i), sha1),
]
)
self.set_config(
[
("floppy_image_{0}".format(i), path),
("x_floppy_image_{0}_sha1".format(i), sha1),
]
)
# blank the rest of the drives
for i in range(len(paths), 4):
self.set_config(
[
("floppy_drive_{0}".format(i), ""),
("x_floppy_drive_{0}_sha1".format(i), ""),
]
)
# blank the rest of the image list
for i in range(len(paths), 20):
self.set_config(
[
("floppy_image_{0}".format(i), ""),
("x_floppy_image_{0}_sha1".format(i), ""),
]
)
def config_startup_scan(cls):
if cls._config_scanned:
return
cls._config_scanned = True
configs_dir = FSGSDirectories.get_configurations_dir()
print("config_startup_scan", configs_dir)
print(LauncherSettings.settings)
settings_mtime = LauncherSettings.get("configurations_dir_mtime")
dir_mtime = cls.get_dir_mtime_str(configs_dir)
if settings_mtime == dir_mtime + "+" + str(Database.VERSION):
print("... mtime not changed", settings_mtime, dir_mtime)
return
database = Database.get_instance()
file_database = FileDatabase.get_instance()
print("... database.find_local_configurations")
local_configs = Database.get_instance().find_local_configurations()
print("... walk configs_dir")
for dir_path, dir_names, file_names in os.walk(configs_dir):
for file_name in file_names:
if not file_name.endswith(".fs-uae"):
continue
path = Paths.join(dir_path, file_name)
if path in local_configs:
local_configs[path] = None
# already exists in database
continue
name, ext = os.path.splitext(file_name)
# search = ConfigurationScanner.create_configuration_search(
# name)
scanner = ConfigurationScanner()
print("[startup] 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))
for path, config_id in local_configs.items():
if config_id is not None:
print("[startup] removing configuration", path)
database.delete_game(id=config_id)
file_database.delete_file(path=path)
print("... commit")
database.commit()
LauncherSettings.set(
"configurations_dir_mtime",
cls.get_dir_mtime_str(configs_dir) + "+" + str(Database.VERSION),
)
def insert_cd(self, drive, path, sha1=None):
if sha1 is None:
sha1 = ""
print("FIXME: not calculating CD checksum just yet")
default_dir = FSGSDirectories.get_cdroms_dir()
path = Paths.contract_path(path, default_dir)
self.set_config([
("cdrom_drive_{0}".format(drive), path),
("x_cdrom_drive_{0}_sha1".format(drive), sha1)])
def get_cdroms_dir(cls):
path = cls.portable_dir("cdroms_dir")
if not path:
if openretro:
path = os.path.join(cls.media_dir(), "CD-ROMs")
else:
path = os.path.join(cls.get_base_dir(), "CD-ROMs")
if not os.path.exists(path):
os.makedirs(path)
path = Paths.get_real_case(path)
return path
def get_kickstarts_dir(cls):
path = cls.portable_dir("kickstarts_dir")
if not path:
if Product.is_fs_uae():
path = os.path.join(cls.get_base_dir(), "Kickstarts")
else:
path = os.path.join(cls.media_dir(), "ROMs")
if not os.path.exists(path):
os.makedirs(path)
path = Paths.get_real_case(path)
return path
def get_controllers_dir(cls):
path = cls.portable_dir("controllers_dir")
if not path:
if openretro:
path = os.path.join(cls.get_data_dir(), "Devs", "Joysticks")
else:
path = os.path.join(cls.get_base_dir(), "Controllers")
if not os.path.exists(path):
os.makedirs(path)
path = Paths.get_real_case(path)
return path
def get_configurations_dir(cls):
path = cls.portable_dir("configurations_dir")
if not path:
if openretro:
path = os.path.join(cls.get_data_dir(), "Configs")
else:
path = os.path.join(cls.get_base_dir(), "Configurations")
if not os.path.exists(path):
os.makedirs(path)
path = Paths.get_real_case(path)
return path
def scan_dir_for_kickstarts(scan_dir):
file_database = FileDatabase.get_instance()
for dir_path, dir_names, file_names in os.walk(scan_dir):
for file_name in file_names:
if not file_name.endswith(".rom"):
continue
path = Paths.join(dir_path, file_name)
if file_database.find_file(path=path):
continue
print("[startup] adding kickstart", path)
ROMManager.add_rom_to_database(path, file_database)
def get_cdroms_dir(cls):
path = cls.portable_dir("cdroms_dir")
if not path:
if openretro:
path = os.path.join(cls.media_dir(), "CD-ROMs")
else:
path = os.path.join(cls.get_base_dir(), "CD-ROMs")
if not os.path.exists(path):
os.makedirs(path)
path = Paths.get_real_case(path)
return path
def get_configurations_dir(cls):
path = cls.portable_dir("configurations_dir")
if not path:
if openretro:
path = os.path.join(cls.get_data_dir(), "Configs")
else:
path = os.path.join(cls.get_base_dir(), "Configurations")
if not os.path.exists(path):
os.makedirs(path)
path = Paths.get_real_case(path)
return path
def get_controllers_dir(cls):
path = cls.portable_dir("controllers_dir")
if not path:
if openretro:
path = os.path.join(cls.get_data_dir(), "Devs", "Joysticks")
else:
path = os.path.join(cls.get_base_dir(), "Controllers")
if not os.path.exists(path):
os.makedirs(path)
path = Paths.get_real_case(path)
return path
def get_hard_drives_dir(cls):
path = cls.portable_dir("hard_drives_dir")
if not path:
if Product.is_fs_uae():
path = os.path.join(cls.get_base_dir(), "Hard Drives")
else:
path = os.path.join(cls.media_dir(), "HardDrives")
if not os.path.exists(path):
os.makedirs(path)
path = Paths.get_real_case(path)
return path
def get_cover_path(self):
sha1 = LauncherConfig.get("front_sha1")
if sha1:
return "sha1:" + sha1
path = self.get_override_path("cover_image")
if path and os.path.exists(path):
return path
if self.uuid:
paths = FSGSDirectories.get_images_dirs()
for dir_ in paths:
p = os.path.join(
dir_,
self.platform,
"Images",
self.uuid[:2],
self.uuid,
"front.png",
)
if os.path.exists(p):
return p
p = os.path.join(
dir_,
self.platform,
"Thumbnails",
self.uuid[:2],
self.uuid,
"front.png",
)
if os.path.exists(p):
return p
letter = self.get_letter(self.name)
if not letter:
return None
name = self.name
override_dir = LauncherConfig.get("covers_dir")
if override_dir:
paths = [Paths.expand_path(override_dir)]
else:
paths = FSGSDirectories.get_covers_dirs()
for dir_ in paths:
path = os.path.join(dir_, letter, name + ".jpg")
if os.path.exists(path):
return path
path = os.path.join(dir_, letter, name + ".png")
if os.path.exists(path):
return path
path = os.path.join(dir_, name + ".jpg")
if os.path.exists(path):
return path
path = os.path.join(dir_, name + ".png")
if os.path.exists(path):
return path
return None
def scan_dir_for_kickstarts(scan_dir):
file_database = FileDatabase.get_instance()
for dir_path, dir_names, file_names in os.walk(scan_dir):
for file_name in file_names:
if not file_name.endswith(".rom"):
continue
path = Paths.join(dir_path, file_name)
if file_database.find_file(path=path):
continue
print("[startup] adding kickstart", path)
ROMManager.add_rom_to_database(path, file_database)
def multi_select(cls, parent=None):
default_dir = FSGSDirectories.get_cdroms_dir()
dialog = LauncherFilePicker(
parent, gettext("Select Multiple CD-ROMs"), "cd", multiple=True
)
if not dialog.show_modal():
return
paths = dialog.get_paths()
paths.sort()
# checksum_tool = ChecksumTool(parent)
for i, path in enumerate(paths):
# sha1 = checksum_tool.checksum(path)
sha1 = ""
print("FIXME: not calculating CD checksum just yet")
path = Paths.contract_path(path, default_dir)
if i < 1:
LauncherConfig.set_multiple(
[
("cdrom_drive_{0}".format(i), path),
("x_cdrom_drive_{0}_sha1".format(i), sha1),
]
)
LauncherConfig.set_multiple(
[
("cdrom_image_{0}".format(i), path),
("x_cdrom_image_{0}_sha1".format(i), sha1),
]
)
# blank the rest of the drives
for i in range(len(paths), 1):
LauncherConfig.set_multiple(
[
("cdrom_drive_{0}".format(i), ""),
("x_cdrom_drive_{0}_sha1".format(i), ""),
]
)
# Config.set("x_cdrom_drive_{0}_sha1".format(i), "")
# Config.set("x_cdrom_drive_{0}_name".format(i), "")
# blank the rest of the image list
for i in range(len(paths), Amiga.MAX_CDROM_IMAGES):
LauncherConfig.set_multiple(
[
("cdrom_image_{0}".format(i), ""),
("x_cdrom_image_{0}_sha1".format(i), ""),
]
)
def multi_select(cls, parent=None, *, config):
default_dir = FSGSDirectories.get_cdroms_dir()
dialog = LauncherFilePicker(
parent, gettext("Select multiple CD-ROMs"), "cd", multiple=True
)
if not dialog.show_modal():
return
paths = dialog.get_paths()
paths.sort()
# checksum_tool = ChecksumTool(parent)
for i, path in enumerate(paths):
# sha1 = checksum_tool.checksum(path)
sha1 = ""
print("FIXME: not calculating CD checksum just yet")
path = Paths.contract_path(path, default_dir)
if i < 1:
config.set_multiple(
[
("cdrom_drive_{0}".format(i), path),
("x_cdrom_drive_{0}_sha1".format(i), sha1),
]
)
config.set_multiple(
[
("cdrom_image_{0}".format(i), path),
("x_cdrom_image_{0}_sha1".format(i), sha1),
]
)
# blank the rest of the drives
for i in range(len(paths), 1):
config.set_multiple(
[
("cdrom_drive_{0}".format(i), ""),
("x_cdrom_drive_{0}_sha1".format(i), ""),
]
)
# Config.set("x_cdrom_drive_{0}_sha1".format(i), "")
# Config.set("x_cdrom_drive_{0}_name".format(i), "")
# blank the rest of the image list
for i in range(len(paths), Amiga.MAX_CDROM_IMAGES):
config.set_multiple(
[
("cdrom_image_{0}".format(i), ""),
("x_cdrom_image_{0}_sha1".format(i), ""),
]
)
def insert_multiple_floppies(self, insert_paths):
paths = []
for path in insert_paths:
embedded_files = []
if path.endswith(".zip"):
archive = Archive(path)
files = archive.list_files()
for file in files:
name, ext = os.path.splitext(file)
# FIXME: get list of floppy extensions from a central
# place
if ext in [".adf", ".ipf"]:
embedded_files.append(file)
if len(embedded_files) > 0:
embedded_files.sort()
print("found embedded floppy images:")
print(embedded_files)
for file in embedded_files:
paths.append(file)
else:
paths.append(path)
default_dir = FSGSDirectories.get_floppies_dir()
checksum_tool = ChecksumTool()
for i, path in enumerate(paths):
sha1 = checksum_tool.checksum(path)
path = Paths.contract_path(path, default_dir)
if i < 4:
self.set_config([
("floppy_drive_{0}".format(i), path),
("x_floppy_drive_{0}_sha1".format(i), sha1),
])
self.set_config([
("floppy_image_{0}".format(i), path),
("x_floppy_image_{0}_sha1".format(i), sha1),
])
# blank the rest of the drives
for i in range(len(paths), 4):
self.set_config([
("floppy_drive_{0}".format(i), ""),
("x_floppy_drive_{0}_sha1".format(i), ""),
])
# blank the rest of the image list
for i in range(len(paths), 20):
self.set_config([
("floppy_image_{0}".format(i), ""),
("x_floppy_image_{0}_sha1".format(i), ""),
])
def kickstart_startup_scan(cls):
if cls._kickstart_scanned:
return
cls._kickstart_scanned = True
print("kickstart_startup_scan")
kickstarts_dir = FSGSDirectories.get_kickstarts_dir()
if LauncherSettings.get(
"kickstarts_dir_mtime"
) == cls.get_dir_mtime_str(kickstarts_dir):
print("... mtime not changed")
else:
file_database = FileDatabase.get_instance()
print("... database.find_local_roms")
local_roms = file_database.find_local_roms()
print("... walk kickstarts_dir")
for dir_path, dir_names, file_names in os.walk(kickstarts_dir):
for file_name in file_names:
if not file_name.lower().endswith(
".rom"
) and not file_name.lower().endswith(".bin"):
continue
path = Paths.join(dir_path, file_name)
if path in local_roms:
local_roms[path] = None
# already exists in database
continue
print("[startup] adding kickstart", path)
ROMManager.add_rom_to_database(path, file_database)
print(local_roms)
for path, file_id in local_roms.items():
if file_id is not None:
print("[startup] removing kickstart", path)
file_database.delete_file(id=file_id)
print("... commit")
file_database.commit()
LauncherSettings.set(
"kickstarts_dir_mtime", cls.get_dir_mtime_str(kickstarts_dir)
)
amiga = Amiga.get_model_config("A500")
for sha1 in amiga["kickstarts"]:
if fsgs.file.find_by_sha1(sha1=sha1):
break
else:
file_database = FileDatabase.get_instance()
cls.amiga_forever_kickstart_scan()
file_database.commit()
def scan(self):
self.set_status(gettext("Scanning files"), gettext("Scanning files"))
file_database = FileDatabase.get_instance()
# database.clear()
scan_dirs = self.get_scan_dirs()
if self.purge_other_dirs:
all_database_file_ids = file_database.get_file_ids()
else:
all_database_file_ids = None
for dir_ in scan_dirs:
if not os.path.exists(dir_):
print("[FILES] Scanner: Directory does not exist:", dir_)
continue
# this is important to make sure the database is portable across
# operating systems
dir_ = Paths.get_real_case(dir_)
self.database_file_ids = file_database.get_file_hierarchy_ids(dir_)
if self.purge_other_dirs:
all_database_file_ids.difference_update(self.database_file_ids)
self.scan_dir(file_database, dir_)
print("Remaining files:", self.database_file_ids)
self.purge_file_ids(self.database_file_ids)
self.set_status(
gettext("Scanning files"), gettext("Committing data...")
)
# update last_file_insert and last_file_delete
file_database.update_last_event_stamps()
print("[FILES] FileScanner.scan - committing data")
file_database.commit()
if self.purge_other_dirs:
self.purge_file_ids(all_database_file_ids)
if self.stop_check():
file_database.rollback()
else:
self.set_status(
gettext("Scanning files"), gettext("Committing data...")
)
print("[FILES] FileScanner.scan - committing data")
file_database.commit()
def scan(self):
self.set_status(gettext("Scanning files"), gettext("Scanning files"))
file_database = FileDatabase.get_instance()
# database.clear()
scan_dirs = self.get_scan_dirs()
if self.purge_other_dirs:
all_database_file_ids = file_database.get_file_ids()
else:
all_database_file_ids = None
for dir_ in scan_dirs:
if not os.path.exists(dir_):
print("[FILES] Scanner: Directory does not exist:", dir_)
continue
# this is important to make sure the database is portable across
# operating systems
dir_ = Paths.get_real_case(dir_)
self.database_file_ids = file_database.get_file_hierarchy_ids(dir_)
if self.purge_other_dirs:
all_database_file_ids.difference_update(self.database_file_ids)
self.scan_dir(file_database, dir_)
print("Remaining files:", self.database_file_ids)
self.purge_file_ids(self.database_file_ids)
self.set_status(
gettext("Scanning files"), gettext("Committing data...")
)
# update last_file_insert and last_file_delete
file_database.update_last_event_stamps()
print("[FILES] FileScanner.scan - committing data")
file_database.commit()
if self.purge_other_dirs:
self.purge_file_ids(all_database_file_ids)
if self.stop_check():
file_database.rollback()
else:
self.set_status(
gettext("Scanning files"), gettext("Committing data...")
)
print("[FILES] FileScanner.scan - committing data")
file_database.commit()
def kickstart_startup_scan(cls):
if cls._kickstart_scanned:
return
cls._kickstart_scanned = True
print("kickstart_startup_scan")
kickstarts_dir = FSGSDirectories.get_kickstarts_dir()
if LauncherSettings.get("kickstarts_dir_mtime") == \
cls.get_dir_mtime_str(kickstarts_dir):
print("... mtime not changed")
else:
file_database = FileDatabase.get_instance()
print("... database.find_local_roms")
local_roms = file_database.find_local_roms()
print("... walk kickstarts_dir")
for dir_path, dir_names, file_names in os.walk(kickstarts_dir):
for file_name in file_names:
if not file_name.lower().endswith(".rom") and not \
file_name.lower().endswith(".bin"):
continue
path = Paths.join(dir_path, file_name)
if path in local_roms:
local_roms[path] = None
# already exists in database
continue
print("[startup] adding kickstart", path)
ROMManager.add_rom_to_database(path, file_database)
print(local_roms)
for path, file_id in local_roms.items():
if file_id is not None:
print("[startup] removing kickstart", path)
file_database.delete_file(id=file_id)
print("... commit")
file_database.commit()
LauncherSettings.set(
"kickstarts_dir_mtime",
cls.get_dir_mtime_str(kickstarts_dir))
amiga = Amiga.get_model_config("A500")
for sha1 in amiga["kickstarts"]:
if fsgs.file.find_by_sha1(sha1=sha1):
break
else:
file_database = FileDatabase.get_instance()
cls.amiga_forever_kickstart_scan()
file_database.commit()
def convert_uri(cls, uri, prefer_path=False):
if uri.startswith("sha1://"):
return cls.open_sha1_uri(uri)
elif uri.startswith("db://"):
# old name for sha1://
return cls.open_sha1_uri(uri)
elif is_http_url(uri):
return cls.open_url(uri)
elif uri.startswith("locker://"):
return open_locker_uri(uri)
else:
if uri.startswith("$"):
uri = Paths.expand_path(uri)
if prefer_path and os.path.exists(uri):
# return helper object so isinstance does not match with str
return File(uri)
return Archive(uri).open(uri)
def expand_default_path(self, src, default_dir):
if "://" in src:
return src, None
src = Paths.expand_path(src, default_dir)
archive = Archive(src)
# if not archive.exists(src):
# dirs = [default_dir]
# for dir in dirs:
# path = os.path.join(dir, src)
# print("checking", repr(path))
# archive = Archive(path)
# if archive.exists(path):
# #if os.path.exists(path):
# src = path
# break
# else:
# raise Exception("Cannot find path for " + repr(src))
return src, archive
def convert_uri(self, uri, prefer_path=False):
if uri.startswith("sha1://"):
return self.open_sha1_uri(uri)
elif uri.startswith("db://"):
# old name for sha1://
return self.open_sha1_uri(uri)
elif is_http_url(uri):
return self.open_url(uri)
elif uri.startswith("locker://"):
return open_locker_uri(
uri, opener_cache_dict=self.opener_cache_dict
)
else:
if uri.startswith("$"):
uri = Paths.expand_path(uri)
if prefer_path and os.path.exists(uri):
# return helper object so isinstance does not match with str
return File(uri)
return Archive(uri).open(uri)
def prepare_hard_drives(self):
print("LaunchHandler.prepare_hard_drives")
current_task.set_progress(gettext("Preparing hard drives..."))
# self.on_progress(gettext("Preparing hard drives..."))
for i in range(0, 10):
key = "hard_drive_{0}".format(i)
src = self.config.get(key, "")
dummy, ext = os.path.splitext(src)
ext = ext.lower()
if is_http_url(src):
name = src.rsplit("/", 1)[-1]
name = urllib.parse.unquote(name)
self.on_progress(gettext("Downloading {0}...".format(name)))
dest = os.path.join(self.temp_dir, name)
Downloader.install_file_from_url(src, dest)
src = dest
elif src.startswith("hd://game/"):
self.unpack_game_hard_drive(i, src)
self.disable_save_states()
return
elif src.startswith("hd://template/workbench/"):
self.prepare_workbench_hard_drive(i, src)
self.disable_save_states()
return
elif src.startswith("hd://template/empty/"):
self.prepare_empty_hard_drive(i, src)
self.disable_save_states()
return
if ext in Archive.extensions:
print("zipped hard drive", src)
self.unpack_hard_drive(i, src)
self.disable_save_states()
elif src.endswith("HardDrive"):
print("XML-described hard drive", src)
self.unpack_hard_drive(i, src)
self.disable_save_states()
else:
src = Paths.expand_path(src)
self.config[key] = src
def get_cover_path(self):
sha1 = LauncherConfig.get("front_sha1")
if sha1:
return "sha1:" + sha1
path = self.get_override_path("cover_image")
if path and os.path.exists(path):
return path
if self.uuid:
paths = FSGSDirectories.get_images_dirs()
for dir_ in paths:
p = os.path.join(dir_, self.platform, "Images",
self.uuid[:2], self.uuid, "front.png")
if os.path.exists(p):
return p
p = os.path.join(dir_, self.platform, "Thumbnails",
self.uuid[:2], self.uuid, "front.png")
if os.path.exists(p):
return p
letter = self.get_letter(self.name)
if not letter:
return None
name = self.name
override_dir = LauncherConfig.get("covers_dir")
if override_dir:
paths = [Paths.expand_path(override_dir)]
else:
paths = FSGSDirectories.get_covers_dirs()
for dir_ in paths:
path = os.path.join(dir_, letter, name + ".jpg")
if os.path.exists(path):
return path
path = os.path.join(dir_, letter, name + ".png")
if os.path.exists(path):
return path
path = os.path.join(dir_, name + ".jpg")
if os.path.exists(path):
return path
path = os.path.join(dir_, name + ".png")
if os.path.exists(path):
return path
return None
def fix_file_checksum(sha1_key, key, base_dir, is_rom=False):
path = config.get(key, "")
# hack to synchronize URLs
# print(repr(path))
if path.startswith("http://") or path.startswith("https://"):
sha1 = path
config[sha1_key] = sha1
return
path = Paths.expand_path(path)
sha1 = config.get(sha1_key, "")
if not path:
return
if sha1:
# assuming sha1 is correct
return
if not os.path.exists(path):
print(repr(path), "does not exist")
path = os.path.join(base_dir, path)
if not os.path.exists(path):
print(repr(path), "does not exist")
return
if os.path.isdir(path):
# could set a fake checksum here or something, to indicate
# that it isn't supposed to be set..
return
print("checksumming", repr(path))
size = os.path.getsize(path)
if size > 64 * 1024 * 1024:
# not checksumming large files right now
print("not checksumming large file")
return
if is_rom:
sha1 = checksum_tool.checksum_rom(path)
else:
sha1 = checksum_tool.checksum(path)
config[sha1_key] = sha1
def prepare_roms(self):
print("LaunchHandler.prepare_roms")
current_task.set_progress(gettext("Preparing kickstart ROMs..."))
amiga_model = self.config.get("amiga_model", "A500")
model_config = Amiga.get_model_config(amiga_model)
roms = [("kickstart_file", model_config["kickstarts"])]
if self.config["kickstart_ext_file"] or model_config["ext_roms"]:
# not all Amigas have extended ROMs
roms.append(("kickstart_ext_file", model_config["ext_roms"]))
if amiga_model.lower() == "cd32/fmv":
roms.append(("fvm_rom", [CD32_FMV_ROM]))
if self.config["graphics_card"].lower().startswith("picasso-iv"):
roms.append(("graphics_card_rom", [PICASSO_IV_74_ROM]))
if self.config["accelerator"].lower() == "cyberstorm-ppc":
roms.append(("accelerator_rom", ["cyberstormppc.rom"]))
if self.config["freezer_cartridge"] == "action-replay-2":
# Ideally, we would want to recognize ROMs based on zeroing the
# first four bytes, but right now we simply recognize a common
# additional version. freezer_cartridge_rom isn't a real option,
# we just want to copy the rom file and let FS-UAE find it
roms.append(("[freezer_cartridge]",
[ACTION_REPLAY_MK_II_2_14_ROM.sha1,
ACTION_REPLAY_MK_II_2_14_MOD_ROM.sha1]))
elif self.config["freezer_cartridge"] == "action-replay-3":
roms.append(("[freezer_cartridge]",
[ACTION_REPLAY_MK_III_3_17_ROM.sha1,
ACTION_REPLAY_MK_III_3_17_MOD_ROM.sha1]))
for config_key, default_roms in roms:
print("ROM:", config_key, default_roms)
src = self.config[config_key]
if not src:
for sha1 in default_roms:
if is_sha1(sha1):
rom_src = self.fsgs.file.find_by_sha1(sha1)
if rom_src:
src = rom_src
break
else:
# roms_dir = FSGSDirectories.get_kickstarts_dir()
# src = os.path.join(roms_dir, sha1)
# if os.path.exists(src):
# break
# loop up file in roms dir instead
src = sha1
elif src == "internal":
continue
elif src:
src = Paths.expand_path(src)
if not src:
raise TaskFailure(
gettext("Did not find required Kickstart or "
"ROM for {}. Wanted one of these files: {}".format(
config_key, repr(default_roms))))
use_temp_kickstarts_dir = False
dest = os.path.join(self.temp_dir, os.path.basename(src))
archive = Archive(src)
stream = None
if not archive.exists(src):
dirs = [self.fsgs.amiga.get_kickstarts_dir()]
for dir in dirs:
path = os.path.join(dir, src)
print("checking", repr(path))
archive = Archive(path)
if archive.exists(path):
src = path
break
else:
try:
stream = self.fsgs.file.open(src)
if stream is None:
raise FileNotFoundError(src)
except FileNotFoundError:
raise TaskFailure(gettext(
"Cannot find required ROM "
"file: {name}".format(name=repr(src))))
with open(dest, "wb") as f:
if stream:
f.write(stream.read())
else:
ROMManager.decrypt_archive_rom(archive, src, file=f)
if use_temp_kickstarts_dir:
self.config[config_key] = os.path.basename(src)
else:
self.config[config_key] = dest
if use_temp_kickstarts_dir:
self.config["kickstarts_dir"] = self.temp_dir
def get_base_dir(cls):
path = fsboot.base_dir()
# Configuration and file database depends on path normalization,
# especially for cross-platform portable mode.
path = Paths.get_real_case(path)
return path
