void checkfilename (char *currentfilename)
{
char *ret = NULL, *fname = NULL;
char *ptr;
char actualpath [PATH_MAX];
struct dirent **namelist;
DIR *dir;
if ((dir = opendir(currentfilename)))
{
dirList=currentfilename;
ptr = realpath(currentfilename, actualpath);
strcpy(currentDir, ptr);
closedir(dir);
}
else
{
if ((menu_load_type == MENU_SELECT_FILE) && confirmselection)
{
selectedFilePath=currentfilename;
if (autostart_autodetect(selectedFilePath.c_str(), NULL, 0, AUTOSTART_MODE_RUN) < 0) {
//ui_error("could not start auto-image");
}
#ifdef ANDROID
SDL_ANDROID_SetScreenKeyboardShown(1);
#endif
running = false;
}
else if ((menu_load_type == MENU_SELECT_DRIVE8) && confirmselection)
{
selectedFilePath8=currentfilename;
int err8 = file_system_attach_disk(8, selectedFilePath8.c_str());
}
else if ((menu_load_type == MENU_SELECT_DRIVE9) && confirmselection)
{
selectedFilePath9=currentfilename;
int err9 = file_system_attach_disk(9, selectedFilePath9.c_str());
}
else if ((menu_load_type == MENU_SELECT_DRIVE10) && confirmselection)
{
selectedFilePath10=currentfilename;
int err10 = file_system_attach_disk(10, selectedFilePath9.c_str());
}
else if ((menu_load_type == MENU_SELECT_DRIVE11) && confirmselection)
{
selectedFilePath11=currentfilename;
int err11 = file_system_attach_disk(11, selectedFilePath10.c_str());
}
if (confirmselection)
unraise_loadMenu_guichan();
}
}
static int set_attach_device_readonly(int value, void *param)
{
unsigned int unit = vice_ptr_to_uint(param);
const char *old_filename;
char *new_filename;
int rc;
int val = value ? 1 : 0;
/* Do nothing if resource is unchanged. */
if (attach_device_readonly_enabled[unit - 8] == val) {
return 0;
}
old_filename = file_system_get_disk_name(unit);
/* If no disk is attached, just changed the resource. */
if (old_filename == NULL) {
attach_device_readonly_enabled[unit - 8] = val;
return 0;
}
/* Old filename will go away after the image is detached. */
new_filename = lib_stralloc(old_filename);
file_system_detach_disk(unit);
attach_device_readonly_enabled[unit - 8] = val;
rc = file_system_attach_disk(unit, new_filename);
lib_free(new_filename);
return rc;
}
static TUI_MENU_CALLBACK(create_disk_image_callback)
{
if (been_activated) {
unsigned int drive;
drive = (unsigned int)param;
if (file_name == NULL) {
tui_error("Specify a disk image name.");
return NULL;
}
if (vdrive_internal_create_format_disk_image(file_name, format_name, image_type[file_type]) < 0) {
tui_error("Could not create disk image!");
return NULL;
}
if (drive > 0) {
if (file_system_attach_disk(drive, file_name) < 0) {
tui_error("Could not attach disk image!");
return NULL;
}
}
ui_update_menus();
}
return NULL;
}
/* Autostart disk image `file_name'. */
int autostart_disk(const char *file_name, const char *program_name,
unsigned int program_number, unsigned int runmode)
{
char *name = NULL;
if (network_connected() || !file_name || !autostart_enabled)
return -1;
/* Get program name first to avoid more than one file handle open on
image. */
if (!program_name && program_number > 0)
name = image_contents_filename_by_number(IMAGE_CONTENTS_DISK,
file_name, 0, program_number);
else
name = lib_stralloc(program_name ? program_name : "*");
if (name) {
autostart_disk_cook_name(&name);
if (!(file_system_attach_disk(8, file_name) < 0)) {
log_message(autostart_log,
"Attached file `%s' as a disk image.", file_name);
reboot_for_autostart(name, AUTOSTART_HASDISK, runmode);
lib_free(name);
return 0;
}
}
autostartmode = AUTOSTART_ERROR;
deallocate_program_name();
if (name)
lib_free(name);
return -1;
}
void initcmdline_check_attach(void)
{
if (machine_class != VICE_MACHINE_VSID) {
/* Handle general-purpose command-line options. */
/* `-autostart' */
if (autostart_string != NULL) {
autostart_autodetect_opt_prgname(autostart_string, 0, autostart_mode);
}
/* `-8', `-9', `-10' and `-11': Attach specified disk image. */
{
int i;
for (i = 0; i < 4; i++) {
if (startup_disk_images[i] != NULL
&& file_system_attach_disk(i + 8, startup_disk_images[i])
< 0) {
log_error(LOG_DEFAULT,
"Cannot attach disk image `%s' to unit %d.",
startup_disk_images[i], i + 8);
}
}
}
/* `-1': Attach specified tape image. */
if (startup_tape_image && tape_image_attach(1, startup_tape_image) < 0) {
log_error(LOG_DEFAULT, "Cannot attach tape image `%s'.",
startup_tape_image);
}
}
cmdline_free_autostart_string();
}
void uiattach_aros(video_canvas_t *canvas, int unit)
{
char *fname=NULL;
char select_txt[50];
if (unit==1)
{
fname=BrowseFile("Select file for tape","#?", canvas);
if (fname!=NULL)
{
if (tape_image_attach(1, fname) < 0)
ui_error(translate_text(IDMES_CANNOT_ATTACH_FILE));
}
}
else
{
sprintf(select_txt,"Select file for unit %d",unit);
fname=BrowseFile(select_txt, "#?", canvas);
if (fname!=NULL)
{
if (file_system_attach_disk(unit, fname) < 0)
ui_error(translate_text(IDMES_CANNOT_ATTACH_FILE));
}
}
}
static void uiattach_disk_dialog(HWND hwnd, WPARAM wparam)
{
TCHAR *st_name;
char *resource;
int unit = 8;
int autostart_index = -1;
SuspendFullscreenModeKeep(hwnd);
switch (wparam & 0xffff) {
case IDM_ATTACH_8:
unit = 8;
break;
case IDM_ATTACH_9:
unit = 9;
break;
case IDM_ATTACH_10:
unit = 10;
break;
case IDM_ATTACH_11:
unit = 11;
break;
}
resource = lib_msprintf("AttachDevice%dReadonly", unit);
if ((st_name = uilib_select_file_autostart(hwnd,
translate_text(IDS_ATTACH_DISK_IMAGE),
UILIB_FILTER_DISK |
#ifdef HAVE_ZLIB
UILIB_FILTER_ZIP |
#endif
UILIB_FILTER_ALL,
UILIB_SELECTOR_TYPE_FILE_LOAD,
UILIB_SELECTOR_STYLE_DISK,
&autostart_index, resource)) != NULL) {
char *name;
name = system_wcstombs_alloc(st_name);
if (autostart_index >= 0) {
if (autostart_autodetect(name, NULL, autostart_index, AUTOSTART_MODE_RUN) < 0) {
ui_error(translate_text(IDS_CANNOT_AUTOSTART_FILE));
}
} else {
if (file_system_attach_disk(unit, name) < 0) {
ui_error(translate_text(IDS_CANNOT_ATTACH_FILE));
}
}
system_wcstombs_free(name);
lib_free(st_name);
}
ResumeFullscreenModeKeep(hwnd);
lib_free(resource);
}
static void ui_fliplist_select_cb(GtkWidget *widget, gpointer data)
{
int unit = GPOINTER_TO_INT(data) & 0xff;
int index = (GPOINTER_TO_INT(data) >> 8) & 0xff;
int i;
if (index == 0) {
fliplist_t list = fliplist_init_iterate(unit);
const char *image = fliplist_get_image(list);
file_system_attach_disk(unit, image);
} else {
for (i = 0; i < index; ++i) {
fliplist_attach_head(unit, 1);
}
}
}
void fliplist_attach_head (unsigned int unit, int direction)
{
if (fliplist[unit - 8] == NULL) {
return;
}
if (direction) {
fliplist[unit - 8] = fliplist[unit - 8]->next;
} else {
fliplist[unit - 8] = fliplist[unit - 8]->prev;
}
if (file_system_attach_disk(fliplist[unit - 8]->unit, fliplist[unit - 8]->image) < 0) {
/* shouldn't happen, so ignore it */
}
}
static BOOL store_dialog_results(HWND hwnd, unsigned int num)
{
char s[MAX_PATH];
TCHAR st[MAX_PATH];
int devtype = ATTACH_DEVICE_NONE;
if (iec_available_busses() & IEC_BUS_IEC) {
resources_set_int_sprintf("IECDevice%d", (IsDlgButtonChecked(hwnd, IDC_TOGGLE_USEIECDEVICE) == BST_CHECKED), num);
}
if (IsDlgButtonChecked(hwnd, IDC_SELECTDISK) == BST_CHECKED || IsDlgButtonChecked(hwnd, IDC_SELECTDIR) == BST_CHECKED) {
devtype = ATTACH_DEVICE_FS;
}
#ifdef HAVE_OPENCBM
if (opencbmlib_is_available()) {
if (IsDlgButtonChecked(hwnd, IDC_SELECTREAL) == BST_CHECKED) {
devtype = ATTACH_DEVICE_REAL;
}
}
#endif
resources_set_int_sprintf("FileSystemDevice%d", devtype, num);
resources_set_int_sprintf("FSDevice%dConvertP00", (IsDlgButtonChecked(hwnd, IDC_TOGGLE_READP00) == BST_CHECKED), num);
resources_set_int_sprintf("FSDevice%dSaveP00", (IsDlgButtonChecked(hwnd, IDC_TOGGLE_WRITEP00) == BST_CHECKED), num);
resources_set_int_sprintf("FSDevice%dHideCBMFiles", (IsDlgButtonChecked(hwnd, IDC_TOGGLE_HIDENONP00) == BST_CHECKED), num);
resources_set_int_sprintf("AttachDevice%dReadonly", (IsDlgButtonChecked(hwnd, IDC_TOGGLE_ATTACH_READONLY) == BST_CHECKED), num);
GetDlgItemText(hwnd, IDC_DIR, st, MAX_PATH);
system_wcstombs(s, st, MAX_PATH);
resources_set_string_sprintf("FSDevice%dDir", s, num);
if (IsDlgButtonChecked(hwnd, IDC_SELECTDISK) == BST_CHECKED) {
GetDlgItemText(hwnd, IDC_DISKIMAGE, st, MAX_PATH);
system_wcstombs(s, st, MAX_PATH);
if (file_system_attach_disk(num, s) < 0 ) {
ui_error(translate_text(IDS_CANNOT_ATTACH_FILE));
return 0;
}
} else {
if ((IsDlgButtonChecked(hwnd, IDC_SELECTDIR) == BST_CHECKED) && file_system_get_disk_name(num)) {
file_system_detach_disk(num);
}
}
return 1;
}
static TUI_MENU_CALLBACK(attach_disk_callback)
{
const char *s;
if (been_activated) {
char *default_item, *directory;
char *name, *file;
unsigned int file_number = 0;
s = file_system_get_disk_name((unsigned int)param);
util_fname_split(s, &directory, &default_item);
name = tui_file_selector("Attach a disk image", directory,
"*.d64;*.d71;*.d81;*.g64;*.g41;*.x64;*.p64;*.d80;*.d82;*.d67;*.d1m;*.d2m;*.d4m;"
"*.d6z;*.d7z;*.d8z;*.g6z;*.g4z;*.x6z;*.zip;*.gz;*.lzh",
default_item, diskcontents_filesystem_read, &file,
&file_number);
if (file_number > 0) {
if (autostart_disk(name, NULL, file_number, AUTOSTART_MODE_RUN) < 0) {
tui_error("Cannot autostart disk image.");
} else {
*behavior = TUI_MENU_BEH_RESUME;
}
} else if (name != NULL && (s == NULL || strcasecmp(name, s) != 0) && file_system_attach_disk((int)param, name) < 0) {
tui_error("Invalid disk image.");
}
lib_free(file);
ui_update_menus();
lib_free(directory);
lib_free(default_item);
lib_free(name);
}
s = file_system_get_disk_name((unsigned int)param);
if (s == NULL || *s == '\0') {
return "(none)";
} else {
return s;
}
}
/* Autostart disk image `file_name'. */
int autostart_disk(const char *file_name, const char *program_name,
unsigned int program_number, unsigned int runmode)
{
char *name = NULL;
if (network_connected() || event_record_active() || event_playback_active()
|| !file_name || !autostart_enabled) {
return -1;
}
/* Get program name first to avoid more than one file handle open on
image. */
if (!program_name && program_number > 0) {
image_contents_t *contents = diskcontents_filesystem_read(file_name);
if (contents) {
name = image_contents_filename_by_number(contents, program_number);
image_contents_destroy(contents);
}
} else {
name = lib_stralloc(program_name ? program_name : "*");
}
if (name) {
autostart_disk_cook_name(&name);
if (!(file_system_attach_disk(8, file_name) < 0)) {
log_message(autostart_log,
"Attached file `%s' as a disk image.", file_name);
reboot_for_autostart(name, AUTOSTART_HASDISK, runmode);
lib_free(name);
return 0;
}
}
autostartmode = AUTOSTART_ERROR;
deallocate_program_name();
lib_free(name);
return -1;
}
static void uiattach_disk_dialog(video_canvas_t *canvas, int idm)
{
char *name;
char *resource;
int unit = 8;
int autostart_index = -1;
switch (idm) {
case IDM_ATTACH_8:
unit = 8;
break;
case IDM_ATTACH_9:
unit = 9;
break;
case IDM_ATTACH_10:
unit = 10;
break;
case IDM_ATTACH_11:
unit = 11;
break;
}
resource = lib_msprintf("AttachDevice%dReadonly", unit);
if ((name = uilib_select_file_autostart(translate_text(IDMS_ATTACH_DISK_IMAGE),
UILIB_FILTER_DISK | UILIB_FILTER_ZIP | UILIB_FILTER_ALL,
UILIB_SELECTOR_TYPE_FILE_LOAD, UILIB_SELECTOR_STYLE_DISK,
&autostart_index, resource)) != NULL) {
if (autostart_index >= 0) {
if (autostart_autodetect(name, NULL, autostart_index, AUTOSTART_MODE_RUN) < 0) {
ui_error(translate_text(IDMES_CANNOT_AUTOSTART_FILE));
}
} else {
if (file_system_attach_disk(unit, name) < 0) {
ui_error(translate_text(IDMES_CANNOT_ATTACH_FILE));
}
}
lib_free(name);
}
lib_free(resource);
}
int autostart_prg_with_disk_image(const char *file_name, fileio_info_t *fh, const char *image_name)
{
const int drive = 8;
const int secondary = 1;
autostart_prg_t *prg;
vdrive_t *vdrive;
int i;
int old_tde_state;
int file_name_size;
BYTE lo,hi;
/* read prg file */
prg = load_prg(file_name, fh);
if (prg == NULL) {
return -1;
}
/* disable TDE */
resources_get_int("DriveTrueEmulation", &old_tde_state);
if (old_tde_state != 0)
resources_set_int("DriveTrueEmulation", 0);
/* create empty image */
if (vdrive_internal_create_format_disk_image(image_name,
(char *)"AUTOSTART", DISK_IMAGE_TYPE_D64) <0 ) {
//log_error(log, "Error creating autostart disk image: %s", image_name);
free_prg(prg);
return -1;
}
/* attach disk image */
if (file_system_attach_disk(drive, image_name) < 0) {
//log_error(log, "Could not attach disk image: %s", image_name);
free_prg(prg);
return -1;
}
/* copy file to disk */
vdrive = file_system_get_vdrive((unsigned int)drive);
if (vdrive == NULL) {
free_prg(prg);
return -1;
}
/* get file name size */
file_name_size = strlen((const char *)fh->name);
if (file_name_size > 16) {
file_name_size = 16;
}
/* open file on disk */
if (vdrive_iec_open(vdrive, (const BYTE *)fh->name,
file_name_size, secondary, NULL) != SERIAL_OK) {
//log_error(log, "Could not open file");
free_prg(prg);
return -1;
}
/* write start address to file */
lo = (BYTE)(prg->start_addr & 0xff);
hi = (BYTE)((prg->start_addr >> 8) & 0xff);
if ((vdrive_iec_write(vdrive, lo, secondary) != SERIAL_OK) ||
(vdrive_iec_write(vdrive, hi, secondary) != SERIAL_OK)) {
//log_error(log, "Could not write file");
free_prg(prg);
return -1;
}
/* write PRG data to file */
for (i = 0; i < prg->size; i++) {
if (vdrive_iec_write(vdrive, prg->data[i], secondary) != SERIAL_OK) {
//log_error(log, "Could not write file");
free_prg(prg);
return -1;
}
}
/* close file */
if (vdrive_iec_close(vdrive, secondary) != SERIAL_OK) {
//log_error(log, "Could not close file");
free_prg(prg);
return -1;
}
/* free prg file */
free_prg(prg);
/* re-enable TDE */
if (old_tde_state != 0)
resources_set_int("DriveTrueEmulation", old_tde_state);
/* ready */
return 0;
}
int autostart_prg_with_disk_image(const char *file_name,
fileio_info_t *fh,
log_t log,
const char *image_name)
{
const int drive = 8;
const int secondary = 1;
autostart_prg_t *prg;
vdrive_t *vdrive;
int i;
int old_tde_state;
int file_name_size;
BYTE data;
unsigned int disk_image_type;
int result, result2;
/* identify disk image type */
switch (drive_get_disk_drive_type(drive - 8)) {
case DRIVE_TYPE_1540:
case DRIVE_TYPE_1541:
case DRIVE_TYPE_1541II:
case DRIVE_TYPE_1551:
case DRIVE_TYPE_1570:
case DRIVE_TYPE_2031:
disk_image_type = DISK_IMAGE_TYPE_D64;
break;
case DRIVE_TYPE_2040:
case DRIVE_TYPE_3040:
case DRIVE_TYPE_4040:
disk_image_type = DISK_IMAGE_TYPE_D67;
break;
case DRIVE_TYPE_1571:
case DRIVE_TYPE_1571CR:
disk_image_type = DISK_IMAGE_TYPE_D71;
break;
case DRIVE_TYPE_1581:
case DRIVE_TYPE_2000:
case DRIVE_TYPE_4000:
disk_image_type = DISK_IMAGE_TYPE_D81;
break;
case DRIVE_TYPE_8050:
disk_image_type = DISK_IMAGE_TYPE_D80;
break;
case DRIVE_TYPE_8250:
case DRIVE_TYPE_1001:
disk_image_type = DISK_IMAGE_TYPE_D82;
break;
default:
log_error(log, "No idea what disk image format to use.");
return -1;
}
/* read prg file */
prg = load_prg(file_name, fh, log);
if (prg == NULL) {
return -1;
}
/* disable TDE */
resources_get_int("DriveTrueEmulation", &old_tde_state);
if (old_tde_state != 0) {
log_message(log, "Turning true drive emulation off.");
resources_set_int("DriveTrueEmulation", 0);
}
do {
result = -1;
/* create empty image */
if (vdrive_internal_create_format_disk_image(image_name, (char *)"AUTOSTART", disk_image_type) < 0) {
log_error(log, "Error creating autostart disk image: %s", image_name);
break;
}
/* attach disk image */
if (file_system_attach_disk(drive, image_name) < 0) {
log_error(log, "Could not attach disk image: %s", image_name);
break;
}
/* get vdrive */
vdrive = file_system_get_vdrive((unsigned int)drive);
if (vdrive == NULL) {
break;
}
/* get file name size */
file_name_size = strlen((const char *)fh->name);
if (file_name_size > 16) {
file_name_size = 16;
}
/* open file on disk */
if (vdrive_iec_open(vdrive, (const BYTE *)fh->name, file_name_size, secondary, NULL) != SERIAL_OK) {
log_error(log, "Could not open file");
break;
}
result2 = 0;
/* write PRG data to file */
for (i = -2; i < (int)prg->size; i++) {
switch (i) {
case -2:
data = (BYTE)prg->start_addr;
break;
case -1:
data = (BYTE)(prg->start_addr >> 8);
break;
default:
data = prg->data[i];
break;
}
if (vdrive_iec_write(vdrive, data, secondary) != SERIAL_OK) {
log_error(log, "Could not write file");
result2 = -1;
break;
}
}
/* close file */
if (vdrive_iec_close(vdrive, secondary) != SERIAL_OK) {
log_error(log, "Could not close file");
break;
}
result = result2;
} while (0);
/* free prg file */
free_prg(prg);
/* re-enable TDE */
if (old_tde_state != 0) {
log_message(log, "Turning true drive emulation on.");
resources_set_int("DriveTrueEmulation", old_tde_state);
}
/* ready */
return result;
}
static UI_CALLBACK(attach_from_fliplist2)
{
file_system_attach_disk(fliplist_get_unit((void *)UI_MENU_CB_PARAM),
fliplist_get_image((void *)UI_MENU_CB_PARAM));
}
static BOOL FdmDoLoadAction(HWND hwnd, const char *szpath, int act, int sact)
{
switch (act) {
case 0:
return file_system_attach_disk(sact + 8, szpath);
case 1:
return tape_image_attach(1, szpath);
case 2:
return fliplist_load_list(sact + 8, szpath, FALSE);
case 3:
return fliplist_load_list(sact + 8, szpath, TRUE);
case 4:
return trap(hwnd, load_snapshot, szpath);
case 5:
switch (sact) {
case 0:
return resources_set_string(VIDEO_PALETTE, szpath);
#ifdef __X128__
case 1:
return resources_set_string("VDC_PaletteFile", szpath);
#endif
#ifdef __XCBM__
case 1:
return resources_set_string("ViciiPaletteFile", szpath);
#endif
}
return -1;
case 6: // rom img
return resources_set_string("KeymapFile", szpath);
case 7:
switch (sact) {
case 0:
return resources_set_string("KernalName", szpath);
case 1:
return resources_set_string("ChargenName", szpath);
case 2:
return resources_set_string("DosName1541", szpath);
case 3:
return resources_set_string("DosName154ii", szpath);
case 4:
return resources_set_string("DosName1571", szpath);
case 5:
return resources_set_string("DosName1581", szpath);
case 6:
return resources_set_string("DosName2031", szpath);
case 7:
return resources_set_string("DosName1001", szpath);
case 8:
return resources_set_string("DosName2040", szpath);
case 9:
return resources_set_string("DosName3040", szpath);
case 10:
return resources_set_string("DosName4040", szpath);
case 11:
return resources_set_string("BasicName", szpath);
case 12:
return resources_set_string("Z80BiosName", szpath);
case 13:
return resources_set_string("Kernal64Name", szpath);
case 14:
return resources_set_string("Basic64Name", szpath);
case 15:
return resources_set_string("Chargen64Name", szpath);
case 16:
return resources_set_string("ChargenIntName", szpath);
case 17:
return resources_set_string("ChargenDEName", szpath);
case 18:
return resources_set_string("ChargenFRName", szpath);
case 19:
return resources_set_string("ChargenSEName", szpath);
case 20:
return resources_set_string("KernalIntName", szpath);
case 21:
return resources_set_string("KernalDEName", szpath);
case 22:
return resources_set_string("KernalFIName", szpath);
case 23:
return resources_set_string("KernalFRName", szpath);
case 24:
return resources_set_string("KernalITName", szpath);
case 25:
return resources_set_string("KernalNOName", szpath);
case 26:
return resources_set_string("KernalSEName", szpath);
case 27:
return resources_set_string("BasicHiName", szpath);
case 28:
return resources_set_string("BasicLoName", szpath);
}
return -1;
case 8:
return machine_romset_file_load(szpath);
case 9:
return resources_load(szpath);
#if defined __X64__ || defined __X128__
case 10:
switch (sact) {
case 0:
return cartridge_attach_image(CARTRIDGE_CRT, szpath);
case 1:
return cartridge_attach_image(CARTRIDGE_GENERIC_8KB, szpath);
case 2:
return cartridge_attach_image(CARTRIDGE_GENERIC_16KB, szpath);
case 3:
return cartridge_attach_image(CARTRIDGE_ACTION_REPLAY, szpath);
case 4:
return cartridge_attach_image(CARTRIDGE_ATOMIC_POWER, szpath);
case 5:
return cartridge_attach_image(CARTRIDGE_EPYX_FASTLOAD, szpath);
case 6:
return cartridge_attach_image(CARTRIDGE_SUPER_SNAPSHOT, szpath);
case 7:
return cartridge_attach_image(CARTRIDGE_SUPER_SNAPSHOT_V5, szpath);
case 8:
return cartridge_attach_image(CARTRIDGE_WESTERMANN, szpath);
case 9:
return cartridge_attach_image(CARTRIDGE_IEEE488, szpath);
case 10:
return cartridge_attach_image(CARTRIDGE_IDE64, szpath);
}
return -1;
#endif
#ifdef __XPET__
case 10:
switch (sact) {
case 0:
return resources_set_string("RomModule9Name", szpath);
case 1:
return resources_set_string("RomModuleAName", szpath);
case 2:
return resources_set_string("RomModuleBName", szpath);
}
return -1;
#endif
#ifdef __XCBM__
case 10:
switch (sact) {
case 0:
return resources_set_string("Cart1Name", szpath);
case 1:
return resources_set_string("Cart2Name", szpath);
case 2:
return resources_set_string("Cart4Name", szpath);
case 3:
return resources_set_string("Cart6Name", szpath);
}
return -1;
#endif
#ifdef __X128__
case 11:
switch (sact) {
case 0:
return resources_set_string("InternalFunctionName", szpath);
case 1:
return resources_set_string("ExternalFunctionName", szpath);
}
return -1;
#endif
}
return -1;
}
static MRESULT EXPENTRY pm_drive(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
static int drive = 0;
switch (msg) {
case WM_INITDLG:
{
int val, i = 0;
HWND ihwnd = WinWindowFromID(hwnd, CBS_IMAGE);
while (i < 10 && ui_status.imageHist[i][0]) {
WinLboxInsertItem(ihwnd, ui_status.imageHist[i++]);
}
WinLboxInsertItem(ihwnd, "");
resources_get_int("DriveTrueEmulation", &val);
WinCheckButton(hwnd, CB_TRUEDRIVE, val);
WinCheckButton(hwnd, RB_DRIVE8|drive, 1);
WinSendMsg(hwnd, WM_SWITCH, (void*)drive, 0);
WinSendMsg(hwnd, WM_DRIVESTATE, (void*)ui_status.lastDriveState, NULL);
for (i = 0; i < 3; i++) {
WinSendMsg(hwnd, WM_TRACK, (void*)i, (void*)(int)(ui_status.lastTrack[i] * 2));
}
}
break;
case WM_COMMAND:
switch (LONGFROMMP(mp1)) {
case PB_CREATE:
create_dialog(hwnd);
return FALSE;
case PB_ATTACH:
ViceFileDialog(hwnd, 0x0100 | (drive + 1), FDS_OPEN_DIALOG);
return FALSE;
case PB_DETACH:
file_system_detach_disk(drive + 8);
return FALSE;
case PB_FLIPADD:
fliplist_add_image(drive + 8);
return FALSE;
case PB_FLIPREMOVE:
fliplist_remove(drive + 8, NULL);
return FALSE;
case PB_FLIP:
fliplist_attach_head(drive + 8, FLIP_NEXT);
return FALSE;
}
break;
case WM_CONTROL:
{
switch (SHORT1FROMMP(mp1)) {
case RB_DRIVE8:
case RB_DRIVE9:
case RB_DRIVE10:
case RB_DRIVE11:
WinSendMsg(hwnd, WM_SWITCH, (void*)(SHORT1FROMMP(mp1) & 0x3), 0);
break;
case CB_TRUEDRIVE:
toggle("DriveTrueEmulation");
WinSendMsg(hwnd, WM_SWITCH, (void*)drive, 0);
break;
case CB_CONVERTP00:
toggle_drive_res("FSDevice%dConvertP00", drive);//);
WinSendMsg(hwnd, WM_SWITCH, (void*)drive, 0);
break;
case CB_SAVEP00:
toggle_drive_res("FileDevice%dSaveP00", drive);
break;
case CB_ALLOWACCESS:
toggle_drive_res("FileSystemDevice%d", drive);
WinSendMsg(hwnd, WM_SWITCH, (void*)drive, 0);
break;
case CB_HIDENONP00:
toggle_drive_res("FSDevice%dHideCBMFiles", drive);
break;
case CB_MEM2000:
toggle_drive_res("Drive%dRAM2000", drive);
break;
case CB_MEM4000:
toggle_drive_res("Drive%dRAM4000", drive);
break;
case CB_MEM6000:
toggle_drive_res("Drive%dRAM6000", drive);
break;
case CB_MEM8000:
toggle_drive_res("Drive%dRAM8000", drive);
break;
case CB_MEMA000:
toggle_drive_res("Drive%dRAMA000", drive);
break;
case CB_READONLY:
toggle_drive_res("AttachDevice%dReadonly", drive);
break;
case CB_PARALLEL:
if (drive == 0 || drive == 1) {
toggle_drive_res("Drive%dParallelCable", drive);
}
break;
case RB_NEVER:
case RB_ASK:
case RB_ALWAYS:
if (drive == 0 || drive == 1) {
resources_set_int_sprintf("Drive%dExtendImagePolicy", (SHORT1FROMMP(mp1) & 0x3), drive + 8);
}
break;
case RB_NONE:
case RB_TRAP:
case RB_SKIP:
if (drive == 0 || drive == 1) {
resources_set_int_sprintf("Drive%dIdleMethod", (SHORT1FROMMP(mp1) & 0x3), drive + 8);
}
break;
case CBS_IMAGE:
if (SHORT2FROMMP(mp1) == CBN_ENTER) {
char psz[CCHMAXPATH];
WinLboxQuerySelectedItemText(hwnd, CBS_IMAGE, psz, CCHMAXPATH);
if (!strlen(psz)) {
file_system_detach_disk(drive + 8);
return FALSE;
}
if (file_system_attach_disk(drive + 8, psz)) {
WinMessageBox(HWND_DESKTOP, hwnd, "Cannot attach specified file.", "VICE/2 Error", 0, MB_OK);
}
}
return FALSE;
case CBS_PATH:
switch (SHORT2FROMMP(mp1)) {
case SPBN_CHANGE:
{
char path[255];
WinSendDlgMsg(hwnd, CBS_PATH, SPBM_QUERYVALUE, &path, 255);
if (!chdir(path)) {
resources_set_string_sprintf("FSDevice%dDir", path, drive + 8);
}
}
break;
case SPBN_KILLFOCUS:
{
const char *path;
resources_get_string_sprintf("FSDevice%dDir", &path, drive + 8);
WinSendDlgMsg(hwnd, CBS_PATH, SPBM_SETARRAY, &path, 1);
WinSetDlgSpinVal(hwnd, CBS_PATH, 0);
}
break;
}
return FALSE;
case CBS_TYPE:
if (SHORT2FROMMP(mp1) == CBN_ENTER && (drive == 0 || drive == 1)) {
const int nr = WinQueryLboxSelectedItem((HWND)mp2);
const int val = WinLboxItemHandle((HWND)mp2, nr);
resources_set_int_sprintf("Drive%dType", val, drive + 8);
}
return FALSE;
}
}
break;
case WM_DRIVEIMAGE:
{
HWND ihwnd = WinWindowFromID(hwnd, CBS_IMAGE);
const char *name = (char *)mp1;
int pos;
for (pos = 0; pos < 9; pos++) {
WinDeleteLboxItem(ihwnd, 0);
}
pos = 0;
while (pos < 10 && ui_status.imageHist[pos][0]) {
WinLboxInsertItem(ihwnd, ui_status.imageHist[pos++]);
}
WinLboxInsertItem(ihwnd, "");
if (drive == (int)mp2) {
WinLboxSelectItem(ihwnd, name[0] ? 0 : pos);
}
}
return FALSE;
case WM_TRACK:
if (!(ui_status.lastDriveState & (1 << (int)mp1))) {
break;
}
WinSetDlgSpinVal(hwnd, SPB_TRACK8+(int)mp1, (int)((int)mp2 / 2));
WinShowDlg(hwnd, SS_HALFTRACK8 + (int)mp1, ((int)mp2 % 2));
break;
case WM_DRIVELEDS:
WinShowDlg(hwnd, SS_LED8+(int)mp1, (int)mp2);
break;
case WM_DRIVESTATE:
WinShowDlg(hwnd, SPB_TRACK8, (int)mp1 & 1 == 1);
WinShowDlg(hwnd, SS_HALFTRACK8, (int)mp1 & 1 == 1);
WinShowDlg(hwnd, SPB_TRACK9, (int)mp1 & 2 == 1);
WinShowDlg(hwnd, SS_HALFTRACK9, (int)mp1 & 2 == 1);
WinShowDlg(hwnd, SS_LED8, 0);
WinShowDlg(hwnd, SS_LED9, 0);
break;
case WM_SWITCH:
drive = (int)mp1;
{
const HWND lbox = WinWindowFromID(hwnd, CBS_TYPE);
int type = 0;
int val;
int res;
int drive89 = (drive == 0 || drive == 1);
resources_get_int("DriveTrueEmulation", &val);
WinLboxEmpty(lbox);
if (drive89) {
int i, nr;
WinCheckButton(hwnd, RB_NEVER | get_drive_res("Drive%dExtendImagePolicy", drive), 1);
WinCheckButton(hwnd, RB_NONE | get_drive_res("Drive%dIdleMethod", drive), 1);
nr = 0;
res = get_drive_res("Drive%dType", drive);
for (i = 0; i < nDRIVES; i++) {
if (!drive_check_type(driveRes[i], drive)) {
continue;
}
WinLboxInsertItem(lbox, driveName[i]);
WinLboxSetItemHandle(lbox, nr, driveRes[i]);
if (res == driveRes[i]) {
type = nr;
}
nr++;
}
} else {
WinCheckButton(hwnd, RB_NEVER, 0);
WinCheckButton(hwnd, RB_ASK, 0);
WinCheckButton(hwnd, RB_ALWAYS, 0);
WinCheckButton(hwnd, RB_NONE, 0);
WinCheckButton(hwnd, RB_SKIP, 0);
WinCheckButton(hwnd, RB_TRAP, 0);
}
WinLboxSelectItem(lbox, type);
WinCheckButton(hwnd, CB_PARALLEL, drive89 && get_drive_res("Drive%dParallelCable", drive) != 0);
WinCheckButton(hwnd, CB_MEM2000, drive89 && get_drive_res("Drive%dRAM2000", drive) != 0);
WinCheckButton(hwnd, CB_MEM4000, drive89 && get_drive_res("Drive%dRAM4000", drive) != 0);
WinCheckButton(hwnd, CB_MEM6000, drive89 && get_drive_res("Drive%dRAM6000", drive) != 0);
WinCheckButton(hwnd, CB_MEM8000, drive89 && get_drive_res("Drive%dRAM8000", drive) != 0);
WinCheckButton(hwnd, CB_MEMA000, drive89 && get_drive_res("Drive%dRAMA000", drive) != 0);
WinEnableControl(hwnd, CB_PARALLEL, drive89 && val);
WinEnableControl(hwnd, RB_NEVER, drive89 && val);
WinEnableControl(hwnd, RB_ASK, drive89 && val);
WinEnableControl(hwnd, RB_ALWAYS, drive89 && val);
WinEnableControl(hwnd, RB_NONE, drive89 && val);
WinEnableControl(hwnd, RB_SKIP, drive89 && val);
WinEnableControl(hwnd, RB_TRAP, drive89 && val);
WinEnableControl(hwnd, CBS_TYPE, drive89 && val);
WinEnableControl(hwnd, CB_MEM2000, drive89 && val);
WinEnableControl(hwnd, CB_MEM4000, drive89 && val);
WinEnableControl(hwnd, CB_MEM6000, drive89 && val);
WinEnableControl(hwnd, CB_MEM8000, drive89 && val);
WinEnableControl(hwnd, CB_MEMA000, drive89 && val);
{
int acc = get_drive_res("FileSystemDevice%d", drive) != 0;
int conv = get_drive_res("FSDevice%dConvertP00", drive) != 0;
if (!conv) {
resources_set_int_sprintf("FSDevice%dHideCBMFiles", 0, drive + 8);
}
WinCheckButton(hwnd, CB_ALLOWACCESS, acc);
WinCheckButton(hwnd, CB_CONVERTP00, conv);
WinCheckButton(hwnd, CB_SAVEP00, get_drive_res("FSDevice%dSaveP00", drive) != 0);
WinCheckButton(hwnd, CB_HIDENONP00, get_drive_res("FSDevice%dHideCBMFiles", drive) != 0);
WinEnableControl(hwnd, CB_ALLOWACCESS, !(drive89 && val));
WinEnableControl(hwnd, CB_SAVEP00, !(drive89 && val) && acc);
WinEnableControl(hwnd, CB_CONVERTP00, !(drive89 && val) && acc);
WinEnableControl(hwnd, CBS_PATH, !(drive89 && val) && acc);
WinEnableControl(hwnd, CB_HIDENONP00, !(drive89 && val) && acc && conv);
WinCheckButton(hwnd, CB_READONLY, get_drive_res("AttachDevice%dReadonly", drive) != 0);
}
{
char tmp[CCHMAXPATH];
int max = WinDlgLboxQueryCount(hwnd, CBS_IMAGE);
int pos = -1;
do {
WinLboxQueryItem(hwnd, CBS_IMAGE, ++pos, tmp, CCHMAXPATH);
}
while (pos < max && strcmp(ui_status.lastImage[drive], tmp));
WinDlgLboxSelectItem(hwnd, CBS_IMAGE, pos);
}
{
const char *path;
resources_get_string_sprintf("FSDevice%dDir", &path, drive + 8);
WinSendDlgMsg(hwnd, CBS_PATH, SPBM_SETARRAY, &path, 1);
WinSetDlgSpinVal(hwnd, CBS_PATH, 0);
}
}
return FALSE;
}
return WinDefDlgProc (hwnd, msg, mp1, mp2);
}
static int drive_snapshot_read_image_module(snapshot_t *s, unsigned int dnr)
{
BYTE major_version, minor_version;
snapshot_module_t *m;
char snap_module_name[10];
WORD word;
char *filename = NULL;
char *request_str;
int len = 0;
FILE *fp;
BYTE sector_data[0x100];
disk_addr_t dadr;
int rc;
drive_t *drive;
drive = drive_context[dnr]->drive;
sprintf(snap_module_name, "NOIMAGE%i", dnr);
m = snapshot_module_open(s, snap_module_name,
&major_version, &minor_version);
if (m != NULL) {
file_system_detach_disk(dnr + 8);
snapshot_module_close(m);
return 0;
}
sprintf(snap_module_name, "IMAGE%i", dnr);
m = snapshot_module_open(s, snap_module_name,
&major_version, &minor_version);
if (m == NULL) {
return 0;
}
if (major_version > IMAGE_SNAP_MAJOR || minor_version > IMAGE_SNAP_MINOR) {
log_error(drive_snapshot_log,
"Snapshot module version (%d.%d) newer than %d.%d.",
major_version, minor_version,
IMAGE_SNAP_MAJOR, IMAGE_SNAP_MINOR);
}
if (SMR_W(m, &word) < 0) {
snapshot_module_close(m);
return -1;
}
switch (word) {
case 1581:
len = D81_FILE_SIZE;
break;
case 8050:
len = D80_FILE_SIZE;
break;
case 8250:
len = D82_FILE_SIZE;
break;
default:
log_error(drive_snapshot_log,
"Snapshot of disk image unknown (type %d)",
(int)word);
snapshot_module_close(m);
return -1;
}
/* create temporary file of the right size */
fp = archdep_mkstemp_fd(&filename, MODE_WRITE);
if (fp == NULL) {
log_error(drive_snapshot_log, "Could not create temporary file!");
snapshot_module_close(m);
return -1;
}
/* blow up the file to needed size */
if (fseek(fp, len - 1, SEEK_SET) < 0
|| (fputc(0, fp) == EOF)) {
log_error(drive_snapshot_log, "Could not create large temporary file");
fclose(fp);
lib_free(filename);
snapshot_module_close(m);
return -1;
}
fclose(fp);
lib_free(filename);
if (file_system_attach_disk(dnr + 8, filename) < 0) {
log_error(drive_snapshot_log, "Invalid Disk Image");
lib_free(filename);
snapshot_module_close(m);
return -1;
}
request_str = lib_msprintf("Disk image unit #%d imported from snapshot",
dnr + 8);
zfile_close_action(filename, ZFILE_REQUEST, request_str);
lib_free(request_str);
/* we use the return code to step through the tracks. So we do not
need any geometry info. */
SMR_BA(m, sector_data, 0x100);
for (dadr.track = 1;; dadr.track++) {
rc = 0;
for (dadr.sector = 0;; dadr.sector++) {
rc = disk_image_write_sector(drive->image, sector_data, &dadr);
if (rc == 0) {
SMR_BA(m, sector_data, 0x100);
} else {
break;
}
}
if (dadr.sector == 0) {
break;
}
}
vdrive_bam_reread_bam(dnr + 8);
snapshot_module_close(m);
m = NULL;
return 0;
}
/**
* Show and process the floppy disk image dialog.
*/
void DlgFloppy_Main(void)
{
int but, i;
char *newdisk;
char dlgname[MAX_FLOPPYDRIVES][64], dlgdiskdir[64];
SDLGui_CenterDlg(floppydlg);
/* Set up dialog to actual values: */
const char *name;
floppydlg[FLOPPYDLG_ATTACH2FLIPLIST].state &= ~SG_SELECTED;
name = file_system_get_disk_name(8); /* Filename */
if (!name)dlgname[0][0] = '\0';
else File_ShrinkName(dlgname[0], name,floppydlg[FLOPPYDLG_DISKA].w);
floppydlg[FLOPPYDLG_DISKA].txt = dlgname[0];
name = file_system_get_disk_name(9); /* Filename */
if (!name)dlgname[1][0] = '\0';
else File_ShrinkName(dlgname[1], name,floppydlg[FLOPPYDLG_DISKB].w);
floppydlg[FLOPPYDLG_DISKB].txt = dlgname[1];
name = file_system_get_disk_name(10); /* Filename */
if (!name)dlgname[2][0] = '\0';
else File_ShrinkName(dlgname[2], name,floppydlg[FLOPPYDLG_DISK2].w);
floppydlg[FLOPPYDLG_DISK2].txt = dlgname[2];
name = file_system_get_disk_name(11); /* Filename */
if (!name)dlgname[3][0] = '\0';
else File_ShrinkName(dlgname[3], name,floppydlg[FLOPPYDLG_DISK3].w);
floppydlg[FLOPPYDLG_DISK3].txt = dlgname[3];
/* Default image directory: */
File_ShrinkName(dlgdiskdir,szDiskImageDirectory,
floppydlg[FLOPPYDLG_IMGDIR].w);
floppydlg[FLOPPYDLG_IMGDIR].txt = dlgdiskdir;
/* Draw and process the dialog */
do
{
but = SDLGui_DoDialog(floppydlg, NULL);
switch (but)
{
case FLOPPYDLG_EJECTA: /* Eject disk in drive A: */
Floppy_SetDiskFileNameNone(0);
dlgname[0][0] = '\0';
file_system_detach_disk(GET_DRIVE(8));
break;
case FLOPPYDLG_BROWSEA: /* Choose a new disk A: */
DlgDisk_BrowseDisk(dlgname[0], 0, FLOPPYDLG_DISKA);
if (strlen(szDiskFileName[0]) > 0){
int drivetype;
printf("load (%s)-",szDiskFileName[0]);
resources_get_int_sprintf("Drive%iType", &drivetype, GET_DRIVE(8));
printf("(Drive%iType)\n",drivetype);
cartridge_detach_image(-1);
tape_image_detach(1);
// file_system_detach_disk(GET_DRIVE(8));
if(File_DoesFileExtensionMatch(szDiskFileName[0],"CRT"))
cartridge_attach_image(CARTRIDGE_CRT, szDiskFileName[0]);
else {
//FIXME
/*
if(File_DoesFileExtensionMatch(szDiskFileName[0],"D81") && drivetype!=1581)
resources_set_int_sprintf("Drive%iType", 1581, GET_DRIVE(8));
else if (drivetype!=1542 && !File_DoesFileExtensionMatch(szDiskFileName[0],"D81"))
resources_set_int_sprintf("Drive%iType", 1542, GET_DRIVE(8));
*/
if (floppydlg[FLOPPYDLG_ATTACH2FLIPLIST].state & SG_SELECTED){
file_system_detach_disk(GET_DRIVE(8));
printf("Attach to flip list\n");
file_system_attach_disk(8, szDiskFileName[0]);
fliplist_add_image(8) ;
}
else {
printf("autostart\n");
autostart_autodetect(szDiskFileName[0], NULL, 0, AUTOSTART_MODE_RUN);
}
}
}
break;
case FLOPPYDLG_EJECTB: /* Eject disk in drive B: */
Floppy_SetDiskFileNameNone(1);
dlgname[1][0] = '\0';
file_system_detach_disk(GET_DRIVE(9));
break;
case FLOPPYDLG_BROWSEB: /* Choose a new disk B: */
DlgDisk_BrowseDisk(dlgname[1], 1, FLOPPYDLG_DISKB);
if (strlen(szDiskFileName[1]) > 0){
file_system_detach_disk(GET_DRIVE(9));
file_system_attach_disk(9, szDiskFileName[1]);
}
case FLOPPYDLG_EJECT2: /* Eject disk in drive A: */
Floppy_SetDiskFileNameNone(2);
dlgname[2][0] = '\0';
file_system_detach_disk(GET_DRIVE(10));
break;
case FLOPPYDLG_BROWSE2: /* Choose a new disk A: */
DlgDisk_BrowseDisk(dlgname[2], 0, FLOPPYDLG_DISK2);
if (strlen(szDiskFileName[2]) > 0){
//strcpy(prefs->DrivePath[2], szDiskFileName[2]);
}
break;
case FLOPPYDLG_EJECT3: /* Eject disk in drive B: */
Floppy_SetDiskFileNameNone(3);
dlgname[3][0] = '\0';
file_system_detach_disk(GET_DRIVE(11));
break;
case FLOPPYDLG_BROWSE3: /* Choose a new disk B: */
DlgDisk_BrowseDisk(dlgname[3], 1, FLOPPYDLG_DISKB);
if (strlen(szDiskFileName[3]) > 0){
// strcpy(prefs->DrivePath[3], szDiskFileName[3]);
}
break;
case FLOPPYDLG_BROWSEIMG:
DlgDisk_BrowseDir(dlgdiskdir,szDiskImageDirectory,floppydlg[FLOPPYDLG_IMGDIR].w);
break;
/*
case FLOPPYDLG_CREATEIMG:
newdisk = DlgNewDisk_Main();
if (newdisk)
{
DlgFloppy_QueryInsert(dlgname[0], FLOPPYDLG_DISKA,
dlgname[1], FLOPPYDLG_DISKB,
newdisk);
free(newdisk);
}
break;
*/
}
gui_poll_events();
}
while (but != FLOPPYDLG_EXIT && but != SDLGUI_QUIT
&& but != SDLGUI_ERROR && !bQuitProgram);
/*
if (floppydlg[FLOPPYDLG_AUTOSTART].state & SG_SELECTED){
if(!ThePrefs.Emul1541Proc){
prefs->Emul1541Proc = !prefs->Emul1541Proc;
}
}
else {
if(ThePrefs.Emul1541Proc){
prefs->Emul1541Proc = !prefs->Emul1541Proc;
}
}
*/
}
