void machine_specific_shutdown(void)
{
/* and the tape */
tape_image_detach_internal(1);
/* and cartridge */
cartridge_detach_image(-1);
ciacore_shutdown(machine_context.cia1);
ciacore_shutdown(machine_context.cia2);
/* close the video chip(s) */
vicii_shutdown();
plus60k_shutdown();
plus256k_shutdown();
c64_256k_shutdown();
cartridge_shutdown();
#ifdef HAVE_MOUSE
mouse_shutdown();
#endif
c64ui_shutdown();
}
static int set_cartridge_file(const char *name, void *param)
{
/* DBG(("cartridge_file: '%s'\n", name)); */
if (cartridge_file == NULL) {
util_string_set(&cartridge_file, ""); /* resource value modified */
}
if (!strcmp(cartridge_file, name)) {
return 0;
}
if (name == NULL || !strlen(name)) {
cartridge_detach_image(-1);
return 0;
}
DBG(("cartridge_file changed: '%s'\n", name));
if (util_file_exists(name)) {
util_string_set(&cartridge_file, name); /* resource value modified */
return try_cartridge_attach(cartridge_type, cartridge_file);
} else {
DBG(("cartridge_file does not exist: '%s'\n", name));
cartridge_type = CARTRIDGE_NONE; /* resource value modified */
util_string_set(&cartridge_file, ""); /* resource value modified */
}
return 0;
}
static UI_MENU_CALLBACK(detach_c64_cart_callback)
{
if (activated) {
cartridge_detach_image(-1);
}
return NULL;
}
void uic64cart_proc(WPARAM wparam, HWND hwnd)
{
switch (wparam & 0xffff) {
case IDM_CART_ATTACH_CRT:
case IDM_CART_ATTACH_8KB:
case IDM_CART_ATTACH_16KB:
case IDM_CART_ATTACH_AR:
case IDM_CART_ATTACH_AR3:
case IDM_CART_ATTACH_AR4:
case IDM_CART_ATTACH_STARDOS:
case IDM_CART_ATTACH_AT:
case IDM_CART_ATTACH_EPYX:
case IDM_CART_ATTACH_IEEE488:
case IDM_CART_ATTACH_RR:
case IDM_CART_ATTACH_IDE64:
case IDM_CART_ATTACH_SS4:
case IDM_CART_ATTACH_SS5:
case IDM_CART_ATTACH_STB:
case IDM_CART_ENABLE_EXPERT:
uic64cart_attach(wparam, hwnd, c64_ui_cartridges);
break;
case IDM_CART_SET_DEFAULT:
cartridge_set_default();
break;
case IDM_CART_DETACH:
cartridge_detach_image();
break;
case IDM_CART_FREEZE:
keyboard_clear_keymatrix();
cartridge_trigger_freeze();
break;
}
}
int vic20ui_handle_X(int Xvalue)
{
if (Xvalue == 5) {
cartridge_detach_image(-1);
}
return 1;
}
void uic64cart_proc(video_canvas_t *canvas, int idm)
{
switch (idm) {
case IDM_CART_ATTACH_CRT:
case IDM_CART_ATTACH_8KB:
case IDM_CART_ATTACH_16KB:
case IDM_CART_ATTACH_AR:
case IDM_CART_ATTACH_AR3:
case IDM_CART_ATTACH_AR4:
case IDM_CART_ATTACH_STARDOS:
case IDM_CART_ATTACH_AT:
case IDM_CART_ATTACH_EPYX:
case IDM_CART_ATTACH_IEEE488:
case IDM_CART_ATTACH_RR:
case IDM_CART_ATTACH_IDE64:
case IDM_CART_ATTACH_SS4:
case IDM_CART_ATTACH_SS5:
case IDM_CART_ATTACH_STB:
case IDM_CART_ENABLE_EXPERT:
uic64cart_attach(canvas, idm, c64_ui_cartridges);
break;
case IDM_CART_SET_DEFAULT:
cartridge_set_default();
break;
case IDM_CART_DETACH:
cartridge_detach_image();
break;
case IDM_CART_FREEZE:
keyboard_clear_keymatrix();
cartridge_trigger_freeze();
break;
}
}
void machine_specific_shutdown(void)
{
/* and the tape */
tape_image_detach_internal(1);
/* and cartridge */
cartridge_detach_image();
ciacore_shutdown(machine_context.cia1);
ciacore_shutdown(machine_context.cia2);
tpicore_shutdown(machine_context.tpi1);
/* close the video chip(s) */
vicii_shutdown();
reu_shutdown();
georam_shutdown();
ramcart_shutdown();
plus60k_shutdown();
plus256k_shutdown();
c64_256k_shutdown();
mmc64_shutdown();
#ifdef HAVE_TFE
/* Shutdown the TFE. */
tfe_shutdown();
#endif
if (vsid_mode) {
vsid_ui_close();
}
c64ui_shutdown();
}
void machine_specific_shutdown(void)
{
/* and the tape */
tape_image_detach_internal(1);
/* and cartridge */
cartridge_detach_image(-1);
ciacore_shutdown(machine_context.cia1);
ciacore_shutdown(machine_context.cia2);
cartridge_shutdown();
#ifdef HAVE_MOUSE
mouse_shutdown();
#endif
/* close the video chip(s) */
vicii_shutdown();
vdc_shutdown();
sid_cmdline_options_shutdown();
c128ui_shutdown();
}
static TUI_MENU_CALLBACK(detach_cartridge_callback)
{
if (been_activated) {
cartridge_detach_image(-1);
}
return NULL;
}
static UI_MENU_CALLBACK(detach_cart_callback)
{
int m;
m = vice_ptr_to_int(param);
if (activated) {
cartridge_detach_image(m);
}
return NULL;
}
static TUI_MENU_CALLBACK(detach_cartridge_callback)
{
const char *s;
if (been_activated) {
cartridge_detach_image(-1);
}
return "";
}
static int c64c128ui_menu_select_config_pre(int *block, int mnum)
{
if (!vsid_mode && (block[0] == 0) && (mnum == CONF_MENU_CARTTYPE))
{
/* must execute cartridge detach before calling ui_set_menu_display_value() */
cartridge_detach_image();
return 0;
}
return -1;
}
static int detach_cartridge_cmdline(const char *param, void *extra_param)
{
/*
* this is called by '+cart' and relies on that command line options
* are processed after the default cartridge gets attached via
* resources/.ini.
*/
cartridge_detach_image(-1);
return 0;
}
/* ---------------------------------------------------------------------*/
int cart_attach_cmdline(const char *param, void *extra_param)
{
int type = vice_ptr_to_int(extra_param);
/* NULL param is used for +cart */
if (!param) {
cartridge_detach_image(-1);
return 0;
}
return cartridge_attach_image(type, param);
}
static TUI_MENU_CALLBACK(detach_cartridge_callback)
{
const char *s;
if (been_activated) {
cartridge_detach_image(-1);
}
s = cartridge_get_file_name((WORD)0);
if (s == NULL || *s == '\0') {
return "(none)";
} else {
return s;
}
}
int c64ui_handle_X(int Xvalue)
{
if (Xvalue==1)
return 1;
if (Xvalue==2)
{
cartridge_detach_image();
return 0;
}
if (Xvalue==3)
{
cartridge_trigger_freeze();
return 0;
}
return 0;
}
void machine_specific_shutdown(void)
{
/* and the tape */
tape_image_detach_internal(1);
/* and cartridge */
cartridge_detach_image(-1);
viacore_shutdown(machine_context.via1);
viacore_shutdown(machine_context.via2);
viacore_shutdown(machine_context.ieeevia1);
viacore_shutdown(machine_context.ieeevia2);
/* close the video chip(s) */
vic_shutdown();
vic20ui_shutdown();
}
void uic64cart_proc(WPARAM wparam, HWND hwnd, int min_id, int max_id)
{
if ((wparam & 0xffff) >= (unsigned int)min_id && (wparam & 0xffff) <= (unsigned int)max_id) {
uic64cart_attach(wparam, hwnd, built_cartridges);
}
switch (wparam & 0xffff) {
case IDM_CART_ATTACH_CRT:
uic64cart_attach(wparam, hwnd, c64_ui_cartridges);
break;
case IDM_CART_SET_DEFAULT:
cartridge_set_default();
break;
case IDM_CART_DETACH:
cartridge_detach_image(-1);
break;
case IDM_CART_FREEZE:
keyboard_clear_keymatrix();
cartridge_trigger_freeze();
break;
}
}
static void io_source_detach(io_source_detach_t *source)
{
switch (source->det_id) {
case IO_DETACH_CART:
if (source->det_cartid != CARTRIDGE_NONE) {
#ifdef IODEBUG
if (source->det_cartid == 0) {
DBG(("IO: cart id in io struct is 0, it should be updated! name: %s\n", source->det_devname));
} else {
DBG(("IO: io_source_detach id:%d name: %s\n", source->det_cartid, source->det_devname));
}
#endif
assert(source->det_cartid != CARTRIDGE_CRT); /* CARTRIDGE_CRT is not allowed at this point */
cartridge_detach_image(source->det_cartid);
}
break;
case IO_DETACH_RESOURCE:
resources_set_int(source->det_name, 0);
break;
}
ui_update_menus();
}
void machine_specific_shutdown(void)
{
/* and cartridge */
cartridge_detach_image(-1);
ciacore_shutdown(machine_context.cia1);
ciacore_shutdown(machine_context.cia2);
scpu64_mem_shutdown();
/* close the video chip(s) */
vicii_shutdown();
cartridge_shutdown();
#ifdef HAVE_MOUSE
mouse_shutdown();
#endif
sid_cmdline_options_shutdown();
scpu64ui_shutdown();
}
/* Probably one should simply remove the size numbers from the IDM_* stuff */
static void vic20_ui_specific(WPARAM wparam, HWND hwnd)
{
TCHAR *st_name;
switch (wparam) {
case IDM_VIC20MODEL_SETTINGS:
ui_vic20model_settings_dialog(hwnd);
break;
case IDM_CART_VIC20_GENERIC:
uicart_attach_special(hwnd, translate_text(IDS_SELECT_GENERIC), UILIB_FILTER_ALL, CARTRIDGE_VIC20_GENERIC);
break;
case IDM_CART_VIC20_UM:
uicart_attach_special(hwnd, translate_text(IDS_SELECT_UM), UILIB_FILTER_ALL, CARTRIDGE_VIC20_UM);
break;
case IDM_CART_VIC20_FP:
uicart_attach_special(hwnd, translate_text(IDS_SELECT_FP), UILIB_FILTER_ALL, CARTRIDGE_VIC20_FP);
break;
case IDM_CART_VIC20_MEGACART:
uicart_attach_special(hwnd, translate_text(IDS_SELECT_MEGACART), UILIB_FILTER_ALL, CARTRIDGE_VIC20_MEGACART);
break;
case IDM_CART_VIC20_FINAL_EXPANSION:
uicart_attach_special(hwnd, translate_text(IDS_SELECT_FINAL_EXPANSION), UILIB_FILTER_ALL, CARTRIDGE_VIC20_FINAL_EXPANSION);
break;
case IDM_CART_SMART_ATTACH:
uicart_attach_special(hwnd, translate_text(IDS_SELECT_CARTRIDGE_IMAGE), UILIB_FILTER_ALL, CARTRIDGE_VIC20_DETECT);
break;
case IDM_CART_VIC20_8KB_2000:
case IDM_CART_VIC20_16KB_4000:
case IDM_CART_VIC20_8KB_6000:
case IDM_CART_VIC20_8KB_A000:
case IDM_CART_VIC20_4KB_B000:
uicart_attach(wparam, hwnd, vic20_ui_cartridges);
break;
case IDM_CART_SET_DEFAULT:
cartridge_set_default();
break;
case IDM_VIC_SETTINGS:
ui_vic_settings_dialog(hwnd);
break;
case IDM_CART_DETACH:
cartridge_detach_image(-1);
break;
case IDM_VIC20_SETTINGS:
ui_vic20_settings_dialog(hwnd);
break;
case IDM_SIDCART_SETTINGS:
ui_sidcart_settings_dialog(hwnd);
break;
case IDM_ACIA_SETTINGS:
ui_acia_settings_dialog(hwnd);
break;
case IDM_GEORAM_SETTINGS:
ui_georam_settings_dialog(hwnd);
break;
case IDM_DIGIMAX_SETTINGS:
ui_digimax_settings_dialog(hwnd);
break;
case IDM_DS12C887RTC_SETTINGS:
ui_ds12c887rtc_settings_dialog(hwnd);
break;
#ifdef HAVE_TFE
case IDM_TFE_SETTINGS:
ui_tfe_settings_dialog(hwnd);
break;
#endif
case IDM_SFX_SE_SETTINGS:
ui_soundexpander_settings_dialog(hwnd);
break;
case IDM_SFX_SS_SETTINGS:
ui_soundsampler_settings_dialog(hwnd);
break;
#ifdef HAVE_MIDI
case IDM_MIDI_SETTINGS:
ui_midi_settings_dialog(hwnd);
break;
#endif
case IDM_JOYPORT_SETTINGS:
ui_joyport_settings_dialog(hwnd, 1, 0, 1, 1, 0);
break;
case IDM_JOY_SETTINGS:
ui_joystick_settings_dialog(hwnd);
break;
case IDM_EXTRA_JOY_SETTINGS:
ui_extra_joystick_settings_dialog(hwnd);
break;
case IDM_MOUSE_SETTINGS:
ui_mouse_settings_dialog(hwnd, 1);
break;
case IDM_ROM_SETTINGS:
uirom_settings_dialog(hwnd, IDD_VIC20ROM_SETTINGS_DIALOG, IDD_VIC20DRIVEROM_SETTINGS_DIALOG,
uirom_settings,
vic20_main_trans, vic20_drive_trans, vic20_generic_trans,
vic20_main_left_group, vic20_main_middle_group, vic20_main_right_group,
vic20_drive_left_group, vic20_drive_middle_group, vic20_drive_right_group);
break;
case IDM_VIDEO_SETTINGS:
ui_video_settings_dialog(hwnd, UI_VIDEO_CHIP_VIC, UI_VIDEO_CHIP_NONE);
break;
case IDM_DRIVE_SETTINGS:
uidrivevic20_settings_dialog(hwnd);
break;
case IDM_RS232USER_SETTINGS:
ui_rs232user_settings_dialog(hwnd);
break;
case IDM_KEYBOARD_SETTINGS:
uikeyboard_settings_dialog(hwnd, &uikeyboard_config);
break;
case IDM_MEGACART_WRITEBACK_FILE:
if ((st_name = uilib_select_file(hwnd, translate_text(IDS_MI_MEGACART_WRITEBACK_FILE), UILIB_FILTER_ALL, UILIB_SELECTOR_TYPE_FILE_SAVE, UILIB_SELECTOR_STYLE_DEFAULT)) != NULL) {
char *name;
name = system_wcstombs_alloc(st_name);
resources_set_string("MegaCartNvRAMfilename", name);
system_wcstombs_free(name);
lib_free(st_name);
}
break;
case IDM_SAMPLER_SETTINGS:
ui_sampler_settings_dialog(hwnd);
break;
case IDM_USERPORT_RTC_58321A_SETTINGS:
ui_userport_rtc_58321a_settings_dialog(hwnd);
break;
case IDM_USERPORT_RTC_DS1307_SETTINGS:
ui_userport_rtc_ds1307_settings_dialog(hwnd);
break;
}
}
/**
* 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;
}
}
*/
}
/* Probably one should simply remove the size numbers from the IDM_* stuff */
static int vic20_ui_specific(video_canvas_t *canvas, int idm)
{
char *fname = NULL;
switch (idm) {
case IDM_VIC_SETTINGS:
ui_vic_settings_dialog();
break;
case IDM_VIC20_MODEL_VIC20_PAL:
vic20model_set(VIC20MODEL_VIC20_PAL);
break;
case IDM_VIC20_MODEL_VIC20_NTSC:
vic20model_set(VIC20MODEL_VIC20_NTSC);
break;
case IDM_VIC20_MODEL_VIC21:
vic20model_set(VIC20MODEL_VIC21);
break;
case IDM_PALETTE_SETTINGS:
ui_video_palette_settings_dialog(canvas, "VICExternalPalette", "VICPaletteFile", translate_text(IDS_VIC_PALETTE_FILENAME));
break;
case IDM_COLOR_SETTINGS:
ui_video_color_settings_dialog(canvas, "VICColorGamma", "VICColorTint", "VICColorSaturation", "VICColorContrast", "VICColorBrightness");
break;
case IDM_RENDER_FILTER:
ui_video_render_filter_settings_dialog(canvas, "VICFilter");
break;
case IDM_CRT_EMULATION_SETTINGS:
ui_video_crt_settings_dialog(canvas, "VICPALScanLineShade", "VICPALBlur", "VICPALOddLinePhase", "VICPALOddLineOffset");
break;
case IDM_CART_VIC20_8KB_2000:
case IDM_CART_VIC20_16KB_4000:
case IDM_CART_VIC20_8KB_6000:
case IDM_CART_VIC20_8KB_A000:
case IDM_CART_VIC20_4KB_B000:
uicart_attach(canvas, idm, vic20_ui_cartridges);
break;
case IDM_CART_VIC20_GENERIC:
uicart_attach_special(canvas, translate_text(IDS_SELECT_GENERIC), UILIB_FILTER_ALL, CARTRIDGE_VIC20_GENERIC);
break;
case IDM_CART_VIC20_FP:
uicart_attach_special(canvas, translate_text(IDS_SELECT_FP), UILIB_FILTER_ALL, CARTRIDGE_VIC20_FP);
break;
case IDM_CART_VIC20_MEGACART:
uicart_attach_special(canvas, translate_text(IDS_SELECT_MEGACART), UILIB_FILTER_ALL, CARTRIDGE_VIC20_MEGACART);
break;
case IDM_CART_VIC20_FINAL_EXPANSION:
uicart_attach_special(canvas, translate_text(IDS_SELECT_FINAL_EXPANSION), UILIB_FILTER_ALL, CARTRIDGE_VIC20_FINAL_EXPANSION);
break;
case IDM_CART_VIC20_SMART_ATTACH:
uicart_attach_special(canvas, translate_text(IDS_SELECT_CARTRIDGE_IMAGE), UILIB_FILTER_ALL, CARTRIDGE_VIC20_DETECT);
break;
case IDM_CART_SET_DEFAULT:
cartridge_set_default();
break;
case IDM_CART_DETACH:
cartridge_detach_image(-1);
break;
case IDM_VIC20_SETTINGS:
ui_vic20_settings_dialog();
break;
case IDM_COMPUTER_ROM_SETTINGS:
ui_vic20_computer_rom_settings_dialog(canvas);
break;
case IDM_DRIVE_ROM_SETTINGS:
ui_vic20_drive_rom_settings_dialog(canvas);
break;
case IDM_DRIVE_SETTINGS:
uidrivevic20_settings_dialog();
break;
case IDM_PRINTER_SETTINGS:
ui_printer_settings_dialog(canvas, 0, 1);
break;
case IDM_RS232USER_SETTINGS:
ui_rs232user_settings_dialog();
break;
case IDM_SIDCART_SETTINGS:
ui_sidcart_settings_dialog("$9800", "$9C00", "VIC20", 0x9800, 0x9c00);
break;
#ifdef AMIGA_OS4
case IDM_JOY_SETTINGS:
ui_joystick_settings_vic20_dialog();
break;
#else
case IDM_JOY_DEVICE_SELECTION:
ui_joystick_device_vic20_dialog();
break;
case IDM_JOY_FIRE_SELECTION:
ui_joystick_fire_vic20_dialog();
break;
#endif
case IDM_MEGACART_WRITEBACK_FILE:
fname = BrowseFile(translate_text(IDMS_MEGACART_WRITEBACK_FILE), "#?", canvas);
if (fname != NULL) {
resources_set_string("MegaCartNvRAMfilename", fname);
}
break;
case IDM_ACIA_SETTINGS:
ui_acia20_settings_dialog();
break;
case IDM_DIGIMAX_SETTINGS:
ui_digimax_vic20_settings_dialog();
break;
case IDM_DS12C887RTC_SETTINGS:
ui_ds12c887rtc_vic20_settings_dialog(canvas);
break;
case IDM_GEORAM_SETTINGS:
ui_georam_vic20_settings_dialog(canvas);
break;
case IDM_SFX_SE_SETTINGS:
ui_soundexpander_vic20_settings_dialog(canvas);
break;
case IDM_SFX_SS_SETTINGS:
ui_soundsampler_settings_dialog(canvas);
break;
case IDM_KEYBOARD_SETTINGS:
// uikeyboard_settings_dialog(hwnd, &uikeyboard_config);
break;
}
return 0;
}
/*
returns -1 on error, else a positive CRT ID
FIXME: to simplify this function a little bit, all subfunctions should
also return the respective CRT ID on success
*/
int crt_attach(const char *filename, BYTE *rawcart)
{
BYTE header[0x40];
int rc, new_crttype;
FILE *fd;
DBG(("crt_attach: %s\n", filename));
fd = fopen(filename, MODE_READ);
if (fd == NULL) {
return -1;
}
if (crt_read_header(fd, header) == -1) {
return -1;
}
new_crttype = (header[0x17] + (header[0x16] * 256));
if (header[0x17] & 0x80) {
/* handle our negative test IDs */
new_crttype -= 0x10000;
}
DBG(("crt_attach ID: %d\n", new_crttype));
/* cart should always be detached. there is no reason for doing fancy checks
here, and it will cause problems incase a cart MUST be detached before
attaching another, or even itself. (eg for initialization reasons)
most obvious reason: attaching a different ROM (software) for the same
cartridge (hardware) */
cartridge_detach_image(new_crttype);
switch (new_crttype) {
case CARTRIDGE_CRT:
rc = generic_crt_attach(fd, rawcart);
if ( rc != CARTRIDGE_NONE) {
new_crttype = rc;
}
break;
case CARTRIDGE_ACTION_REPLAY:
rc = actionreplay_crt_attach(fd, rawcart);
break;
case CARTRIDGE_ACTION_REPLAY2:
rc = actionreplay2_crt_attach(fd, rawcart);
break;
case CARTRIDGE_ACTION_REPLAY3:
rc = actionreplay3_crt_attach(fd, rawcart);
break;
case CARTRIDGE_ACTION_REPLAY4:
rc = actionreplay4_crt_attach(fd, rawcart);
break;
case CARTRIDGE_ATOMIC_POWER:
rc = atomicpower_crt_attach(fd, rawcart);
break;
case CARTRIDGE_CAPTURE:
rc = capture_crt_attach(fd, rawcart);
break;
case CARTRIDGE_COMAL80:
rc = comal80_crt_attach(fd, rawcart);
break;
case CARTRIDGE_DELA_EP256:
rc = delaep256_crt_attach(fd, rawcart);
break;
case CARTRIDGE_DELA_EP64:
rc = delaep64_crt_attach(fd, rawcart);
break;
case CARTRIDGE_DELA_EP7x8:
rc = delaep7x8_crt_attach(fd, rawcart);
break;
case CARTRIDGE_DIASHOW_MAKER:
rc = dsm_crt_attach(fd, rawcart);
break;
case CARTRIDGE_DINAMIC:
rc = dinamic_crt_attach(fd, rawcart);
break;
case CARTRIDGE_EASYFLASH:
rc = easyflash_crt_attach(fd, rawcart, header, filename);
break;
case CARTRIDGE_EPYX_FASTLOAD:
rc = epyxfastload_crt_attach(fd, rawcart);
break;
case CARTRIDGE_EXOS:
rc = exos_crt_attach(fd, rawcart);
break;
case CARTRIDGE_EXPERT:
rc = expert_crt_attach(fd, rawcart, filename);
break;
case CARTRIDGE_FINAL_I:
rc = final_v1_crt_attach(fd, rawcart);
break;
case CARTRIDGE_FINAL_III:
rc = final_v3_crt_attach(fd, rawcart);
break;
case CARTRIDGE_FINAL_PLUS:
rc = final_plus_crt_attach(fd, rawcart);
break;
case CARTRIDGE_FREEZE_FRAME:
rc = freezeframe_crt_attach(fd, rawcart);
break;
case CARTRIDGE_FREEZE_MACHINE:
rc = freezemachine_crt_attach(fd, rawcart);
break;
case CARTRIDGE_FUNPLAY:
rc = funplay_crt_attach(fd, rawcart);
break;
case CARTRIDGE_GAME_KILLER:
rc = gamekiller_crt_attach(fd, rawcart);
break;
case CARTRIDGE_GS:
rc = gs_crt_attach(fd, rawcart);
break;
case CARTRIDGE_IDE64:
rc = ide64_crt_attach(fd, rawcart);
break;
case CARTRIDGE_IEEE488:
rc = tpi_crt_attach(fd, rawcart);
break;
case CARTRIDGE_ISEPIC:
rc = isepic_crt_attach(fd, rawcart, filename);
break;
case CARTRIDGE_KCS_POWER:
rc = kcs_crt_attach(fd, rawcart);
break;
case CARTRIDGE_KINGSOFT:
rc = kingsoft_crt_attach(fd, rawcart);
break;
case CARTRIDGE_MACH5:
rc = mach5_crt_attach(fd, rawcart);
break;
case CARTRIDGE_MAGIC_DESK:
rc = magicdesk_crt_attach(fd, rawcart);
break;
case CARTRIDGE_MAGIC_FORMEL:
rc = magicformel_crt_attach(fd, rawcart);
break;
case CARTRIDGE_MAGIC_VOICE:
rc = magicvoice_crt_attach(fd, rawcart);
break;
case CARTRIDGE_MIKRO_ASSEMBLER:
rc = mikroass_crt_attach(fd, rawcart);
break;
case CARTRIDGE_MMC64:
rc = mmc64_crt_attach(fd, rawcart);
break;
case CARTRIDGE_MMC_REPLAY:
rc = mmcreplay_crt_attach(fd, rawcart, filename);
break;
case CARTRIDGE_OCEAN:
rc = ocean_crt_attach(fd, rawcart);
break;
case CARTRIDGE_P64:
rc = p64_crt_attach(fd, rawcart);
break;
case CARTRIDGE_PAGEFOX:
rc = pagefox_crt_attach(fd, rawcart);
break;
case CARTRIDGE_RETRO_REPLAY:
rc = retroreplay_crt_attach(fd, rawcart, filename);
break;
case CARTRIDGE_REX_EP256:
rc = rexep256_crt_attach(fd, rawcart);
break;
case CARTRIDGE_REX:
rc = rex_crt_attach(fd, rawcart);
break;
case CARTRIDGE_ROSS:
rc = ross_crt_attach(fd, rawcart);
break;
case CARTRIDGE_SIMONS_BASIC:
rc = simon_crt_attach(fd, rawcart);
break;
case CARTRIDGE_STARDOS:
rc = stardos_crt_attach(fd, rawcart);
break;
case CARTRIDGE_SNAPSHOT64:
rc = snapshot64_crt_attach(fd, rawcart);
break;
case CARTRIDGE_STRUCTURED_BASIC:
rc = stb_crt_attach(fd, rawcart);
break;
case CARTRIDGE_SUPER_GAMES:
rc = supergames_crt_attach(fd, rawcart);
break;
case CARTRIDGE_SUPER_SNAPSHOT:
rc = supersnapshot_v4_crt_attach(fd, rawcart);
break;
case CARTRIDGE_SUPER_SNAPSHOT_V5:
rc = supersnapshot_v5_crt_attach(fd, rawcart);
break;
case CARTRIDGE_SUPER_EXPLODE_V5:
rc = se5_crt_attach(fd, rawcart);
break;
case CARTRIDGE_WARPSPEED:
rc = warpspeed_crt_attach(fd, rawcart);
break;
case CARTRIDGE_WESTERMANN:
rc = westermann_crt_attach(fd, rawcart);
break;
case CARTRIDGE_ZAXXON:
rc = zaxxon_crt_attach(fd, rawcart);
break;
default:
archdep_startup_log_error("unknown CRT ID: %d\n", new_crttype);
rc = -1;
break;
}
fclose(fd);
if (rc == -1) {
DBG(("crt_attach error (%d)\n", rc));
return -1;
}
DBG(("crt_attach return ID: %d\n", new_crttype));
return new_crttype;
}
static UI_CALLBACK(detach_cartridge)
{
cartridge_detach_image(-1);
}
int vic20cart_snapshot_read_module(snapshot_t *s)
{
BYTE vmajor, vminor;
snapshot_module_t *m;
int new_cart_type, cartridge_reset;
int ret = 0;
m = snapshot_module_open(s, SNAP_MODULE_NAME, &vmajor, &vminor);
if (m == NULL) {
return -1;
}
if (vmajor != VIC20CART_DUMP_VER_MAJOR) {
snapshot_module_close(m);
return -1;
}
if (SMR_DW_INT(m, &new_cart_type) < 0) {
snapshot_module_close(m);
return -1;
}
snapshot_module_close(m);
/* disable cartridge reset while detaching old cart */
resources_get_int("CartridgeReset", &cartridge_reset);
resources_set_int("CartridgeReset", 0);
cartridge_detach_image(-1);
resources_set_int("CartridgeReset", cartridge_reset);
/* disallow "set as default" and write back */
cartridge_is_from_snapshot = 1;
vic20cart_type = new_cart_type;
mem_cartridge_type = new_cart_type;
switch (vic20cart_type) {
case CARTRIDGE_VIC20_GENERIC:
ret = generic_snapshot_read_module(s);
break;
case CARTRIDGE_VIC20_FP:
ret = vic_fp_snapshot_read_module(s);
break;
case CARTRIDGE_VIC20_MEGACART:
ret = megacart_snapshot_read_module(s);
break;
case CARTRIDGE_VIC20_FINAL_EXPANSION:
ret = finalexpansion_snapshot_read_module(s);
break;
case CARTRIDGE_NONE:
/* cart already detached, nothing to do */
break;
default:
/* unknown cart */
ret = -1;
break;
}
if (ret < 0) {
vic20cart_type = CARTRIDGE_NONE;
mem_cartridge_type = CARTRIDGE_NONE;
}
return ret;
}
int cartridge_attach_image(int type, const char *filename)
{
int type_orig;
int generic_multifile = 0;
int ret=0;
/* Attaching no cartridge always works. */
if (type == CARTRIDGE_NONE || filename==NULL || *filename == '\0')
return 0;
log_message(LOG_DEFAULT, "Attached cartridge type %d, file=`%s'.",
type, filename);
type_orig=type;
switch (type_orig) {
case CARTRIDGE_VIC20_DETECT:
case CARTRIDGE_VIC20_4KB_2000:
case CARTRIDGE_VIC20_8KB_2000:
case CARTRIDGE_VIC20_4KB_6000:
case CARTRIDGE_VIC20_8KB_6000:
case CARTRIDGE_VIC20_4KB_A000:
case CARTRIDGE_VIC20_8KB_A000:
case CARTRIDGE_VIC20_4KB_B000:
case CARTRIDGE_VIC20_8KB_4000:
case CARTRIDGE_VIC20_4KB_4000:
case CARTRIDGE_VIC20_16KB_2000:
case CARTRIDGE_VIC20_16KB_4000:
case CARTRIDGE_VIC20_16KB_6000:
/*
* For specific layouts only detach if we were something else than
* CARTRIDGE_VIC20_GENERIC before.
* This allows us to add images to a generic type.
*/
if (vic20cart_type != CARTRIDGE_VIC20_GENERIC) {
cartridge_detach_image(-1);
}
generic_multifile = 1;
type=CARTRIDGE_VIC20_GENERIC;
break;
case CARTRIDGE_VIC20_GENERIC:
/*
* this is because the only generic cart that is attachable
* will be attached as a auto detected multi file cart for now
* Remove when this changes.
*/
generic_multifile = 1;
break;
default:
cartridge_detach_image(-1);
}
switch (type) {
case CARTRIDGE_VIC20_GENERIC:
ret = generic_bin_attach(type_orig, filename);
break;
case CARTRIDGE_VIC20_FP:
ret = vic_fp_bin_attach(filename);
break;
case CARTRIDGE_VIC20_MEGACART:
ret = megacart_bin_attach(filename);
break;
case CARTRIDGE_VIC20_FINAL_EXPANSION:
ret = finalexpansion_bin_attach(filename);
break;
}
vic20cart_type = type;
if (generic_multifile) {
util_string_set(&cartfile, NULL);
} else {
util_string_set(&cartfile, filename);
}
if (ret == 0) {
cartridge_attach(type,NULL);
}
return ret;
}
int vic20cart_snapshot_read_module(snapshot_t *s)
{
BYTE vmajor, vminor;
snapshot_module_t *m;
int new_cart_type, cartridge_reset;
BYTE i;
BYTE number_of_carts;
int cart_ids[VIC20CART_DUMP_MAX_CARTS];
m = snapshot_module_open(s, SNAP_MODULE_NAME, &vmajor, &vminor);
if (m == NULL) {
return -1;
}
if (vmajor != VIC20CART_DUMP_VER_MAJOR) {
goto fail;
}
if (SMR_DW_INT(m, &new_cart_type) < 0) {
goto fail;
}
if (SMR_B(m, &number_of_carts) < 0) {
goto fail;
}
/* Not much to do if no carts in snapshot */
if (number_of_carts == 0) {
return snapshot_module_close(m);
}
if (number_of_carts > VIC20CART_DUMP_MAX_CARTS) {
DBG(("CART snapshot read: carts %i > max %i\n", number_of_carts, VIC20CART_DUMP_MAX_CARTS));
goto fail;
}
/* Read cart IDs */
for (i = 0; i < number_of_carts; i++) {
if (SMR_DW_INT(m, &cart_ids[i]) < 0) {
goto fail;
}
}
snapshot_module_close(m);
/* disable cartridge reset while detaching old cart */
resources_get_int("CartridgeReset", &cartridge_reset);
resources_set_int("CartridgeReset", 0);
cartridge_detach_image(-1);
resources_set_int("CartridgeReset", cartridge_reset);
/* disallow "set as default" and write back */
cartridge_is_from_snapshot = 1;
vic20cart_type = new_cart_type;
mem_cartridge_type = new_cart_type;
/* Read individual cart data */
for (i = 0; i < number_of_carts; i++) {
switch (cart_ids[i]) {
case CARTRIDGE_VIC20_FINAL_EXPANSION:
if (finalexpansion_snapshot_read_module(s) < 0) {
return -1;
}
break;
case CARTRIDGE_VIC20_IO2_RAM:
if (ioramcart_io2_snapshot_read_module(s) < 0) {
return -1;
}
break;
case CARTRIDGE_VIC20_IO3_RAM:
if (ioramcart_io3_snapshot_read_module(s) < 0) {
return -1;
}
break;
case CARTRIDGE_VIC20_MEGACART:
if (megacart_snapshot_read_module(s) < 0) {
return -1;
}
break;
case CARTRIDGE_VIC20_UM:
if (vic_um_snapshot_read_module(s) < 0) {
return -1;
}
break;
case CARTRIDGE_VIC20_IEEE488:
if (vic20_ieee488_snapshot_read_module(s) < 0) {
return -1;
}
break;
#ifdef HAVE_MIDI
case CARTRIDGE_MIDI_MAPLIN:
if (vic20_midi_snapshot_read_module(s) < 0) {
return -1;
}
break;
#endif
case CARTRIDGE_VIC20_SIDCART:
if (sidcart_snapshot_read_module(s) < 0) {
return -1;
}
break;
case CARTRIDGE_VIC20_FP:
if (vic_fp_snapshot_read_module(s) < 0) {
return -1;
}
break;
case CARTRIDGE_ACIA:
if (aciacart_snapshot_read_module(s) < 0) {
return -1;
}
break;
case CARTRIDGE_DIGIMAX:
if (digimax_snapshot_read_module(s) < 0) {
return -1;
}
break;
case CARTRIDGE_DS12C887RTC:
if (ds12c887rtc_snapshot_read_module(s) < 0) {
return -1;
}
break;
case CARTRIDGE_GEORAM:
if (georam_read_snapshot_module(s) < 0) {
return -1;
}
break;
case CARTRIDGE_SFX_SOUND_EXPANDER:
if (sfx_soundexpander_snapshot_read_module(s) < 0) {
return -1;
}
break;
case CARTRIDGE_SFX_SOUND_SAMPLER:
if (sfx_soundsampler_snapshot_read_module(s) < 0) {
return -1;
}
break;
#ifdef HAVE_TFE
case CARTRIDGE_TFE:
if (tfe_snapshot_read_module(s) < 0) {
return -1;
}
break;
#endif
}
}
if (vic20cart_type == CARTRIDGE_VIC20_GENERIC) {
if (generic_snapshot_read_module(s) < 0) {
return -1;
}
}
return 0;
fail:
snapshot_module_close(m);
return -1;
}
static int cbm5x0_ui_specific(video_canvas_t *canvas, int idm)
{
switch (idm) {
case IDM_CIA_SETTINGS:
ui_single_cia_model_dialog();
break;
case IDM_LOAD_CART_1XXX:
cbm2_cart_attach(canvas, CARTRIDGE_CBM2_8KB_1000);
break;
case IDM_UNLOAD_CART_1XXX:
cartridge_detach_image(CARTRIDGE_CBM2_8KB_1000);
break;
case IDM_LOAD_CART_2_3XXX:
cbm2_cart_attach(canvas, CARTRIDGE_CBM2_8KB_2000);
break;
case IDM_UNLOAD_CART_2_3XXX:
cartridge_detach_image(CARTRIDGE_CBM2_8KB_2000);
break;
case IDM_LOAD_CART_4_5XXX:
cbm2_cart_attach(canvas, CARTRIDGE_CBM2_16KB_4000);
break;
case IDM_UNLOAD_CART_4_5XXX:
cartridge_detach_image(CARTRIDGE_CBM2_16KB_4000);
break;
case IDM_LOAD_CART_6_7XXX:
cbm2_cart_attach(canvas, CARTRIDGE_CBM2_16KB_6000);
break;
case IDM_UNLOAD_CART_6_7XXX:
cartridge_detach_image(CARTRIDGE_CBM2_16KB_6000);
break;
case IDM_CBM2_MODEL_510_PAL:
cbm2model_set(CBM2MODEL_510_PAL);
break;
case IDM_CBM2_MODEL_510_NTSC:
cbm2model_set(CBM2MODEL_510_NTSC);
break;
case IDM_PALETTE_SETTINGS:
ui_video_palette_settings_dialog(canvas, "VICIIExternalPalette", "VICIIPaletteFile", translate_text(IDS_VICII_PALETTE_FILENAME));
break;
case IDM_COLOR_SETTINGS:
ui_video_color_settings_dialog(canvas, "VICIIColorGamma", "VICIIColorTint", "VICIIColorSaturation", "VICIIColorContrast", "VICIIColorBrightness");
break;
case IDM_RENDER_FILTER:
ui_video_render_filter_settings_dialog(canvas, "VICIIFilter");
break;
case IDM_CRT_EMULATION_SETTINGS:
ui_video_crt_settings_dialog(canvas, "VICIIPALScanLineShade", "VICIIPALBlur", "VICIIPALOddLinePhase", "VICIIPALOddLineOffset");
break;
case IDM_CBM5X0_SETTINGS:
ui_cbm5x0_settings_dialog();
break;
case IDM_SID_SETTINGS:
ui_sid_settings2_dialog();
break;
case IDM_COMPUTER_ROM_SETTINGS:
ui_cbm2_computer_rom_settings_dialog(canvas);
break;
case IDM_DRIVE_ROM_SETTINGS:
ui_cbm2_drive_rom_settings_dialog(canvas);
break;
case IDM_DRIVE_SETTINGS:
uidrivepetcbm2_settings_dialog();
break;
case IDM_PRINTER_SETTINGS:
ui_printer_settings_dialog(canvas, 1, 1);
break;
case IDM_ACIA_SETTINGS:
ui_acia_settings_dialog();
break;
#ifdef AMIGA_OS4
case IDM_JOY_SETTINGS:
ui_joystick_settings_cbm5x0_dialog();
break;
#else
case IDM_JOY_DEVICE_SELECTION:
ui_joystick_device_cbm5x0_dialog();
break;
case IDM_JOY_FIRE_SELECTION:
ui_joystick_fire_cbm5x0_dialog();
break;
#endif
case IDM_KEYBOARD_SETTINGS:
// uikeyboard_settings_dialog(hwnd, &uikeyboard_config);
break;
}
return 0;
}
/*
attach cartridge image
type == -1 NONE
type == 0 CRT format
returns -1 on error, 0 on success
*/
int cartridge_attach_image(int type, const char *filename)
{
BYTE *rawcart;
char *abs_filename;
int carttype = CARTRIDGE_NONE;
int cartid = CARTRIDGE_NONE;
int oldmain = CARTRIDGE_NONE;
int slotmain = 0;
if (filename == NULL) {
return -1;
}
/* Attaching no cartridge always works. */
if (type == CARTRIDGE_NONE || *filename == '\0') {
return 0;
}
if (archdep_path_is_relative(filename)) {
archdep_expand_path(&abs_filename, filename);
} else {
abs_filename = lib_stralloc(filename);
}
if (type == CARTRIDGE_CRT) {
carttype = crt_getid(abs_filename);
if (carttype == -1) {
log_message(LOG_DEFAULT, "CART: '%s' is not a valid CRT file.", abs_filename);
lib_free(abs_filename);
return -1;
}
} else {
carttype = type;
}
DBG(("CART: cartridge_attach_image type: %d ID: %d\n", type, carttype));
/* allocate temporary array */
rawcart = lib_malloc(C64CART_IMAGE_LIMIT);
/* cart should always be detached. there is no reason for doing fancy checks
here, and it will cause problems incase a cart MUST be detached before
attaching another, or even itself. (eg for initialization reasons)
most obvious reason: attaching a different ROM (software) for the same
cartridge (hardware) */
slotmain = cart_is_slotmain(carttype);
if (slotmain) {
/* if the cart to be attached is in the "Main Slot", detach whatever
cart currently is in the "Main Slot" */
oldmain = cart_getid_slotmain();
if (oldmain != CARTRIDGE_NONE) {
DBG(("CART: detach slot main ID: %d\n", oldmain));
cartridge_detach_image(oldmain);
}
}
if (oldmain != carttype) {
DBG(("CART: detach %s ID: %d\n", slotmain ? "slot main" : "other slot", carttype));
cartridge_detach_image(carttype);
}
if (type == CARTRIDGE_CRT) {
DBG(("CART: attach CRT ID: %d '%s'\n", carttype, filename));
cartid = crt_attach(abs_filename, rawcart);
if (cartid == CARTRIDGE_NONE) {
goto exiterror;
}
if (type < 0) {
DBG(("CART: attach generic CRT ID: %d\n", type));
}
} else {
DBG(("CART: attach BIN ID: %d '%s'\n", carttype, filename));
cartid = carttype;
if (cart_bin_attach(carttype, abs_filename, rawcart) < 0) {
goto exiterror;
}
}
if (cart_is_slotmain(cartid)) {
DBG(("cartridge_attach MAIN ID: %d\n", cartid));
mem_cartridge_type = cartid;
cart_romhbank_set_slotmain(0);
cart_romlbank_set_slotmain(0);
} else {
DBG(("cartridge_attach (other) ID: %d\n", cartid));
}
DBG(("CART: attach RAW ID: %d\n", cartid));
cart_attach(cartid, rawcart);
cart_power_off();
if (cart_is_slotmain(cartid)) {
/* "Main Slot" */
DBG(("CART: set main slot ID: %d type: %d\n", carttype, type));
c64cart_type = type;
if (type == CARTRIDGE_CRT) {
crttype = carttype;
}
util_string_set(&cartfile, abs_filename);
}
DBG(("CART: cartridge_attach_image type: %d ID: %d done.\n", type, carttype));
lib_free(rawcart);
log_message(LOG_DEFAULT, "CART: attached '%s' as ID %d.", abs_filename, carttype);
lib_free(abs_filename);
return 0;
exiterror:
DBG(("CART: error\n"));
lib_free(rawcart);
log_message(LOG_DEFAULT, "CART: could not attach '%s'.", abs_filename);
lib_free(abs_filename);
return -1;
}
