void vic20ui_attach_cart(char *imagefile, int carttype)
{
if (carttype == 0) {
carttype = CARTRIDGE_VIC20_GENERIC;
}
cartridge_attach_image(carttype, imagefile);
}
static TUI_MENU_CALLBACK(attach_cartridge_callback)
{
const char *s;
int type = (int)param;
if (been_activated) {
char *default_item, *directory;
char *name;
s = cartridge_get_file_name(cartridge_type_to_address(type));
if (s == NULL) {
directory = default_item = NULL;
} else {
util_fname_split(s, &directory, &default_item);
}
name = tui_file_selector("Attach cartridge image", directory, "*", default_item, NULL, NULL, NULL);
if (name != NULL && (s == NULL || strcasecmp(name, s) != 0) && cartridge_attach_image(type, name) < 0) {
tui_error("Invalid cartridge image.");
}
ui_update_menus();
lib_free(name);
}
/* This is redundant if `been_activated' is nonzero, but let's stay on
the safe side. */
s = cartridge_get_file_name(cartridge_type_to_address(type));
if (s == NULL || *s == '\0') {
return "(none)";
} else {
return s;
}
}
void uicart_attach(WPARAM wparam, HWND hwnd,
const uicart_params_t *cartridges)
{
int i;
TCHAR *st_name;
i = 0;
while ((cartridges[i].wparam != wparam) && (cartridges[i].wparam != 0))
i++;
if (cartridges[i].wparam == 0) {
ui_error(translate_text(IDS_BAD_CARTRIDGE_CONFIG));
return;
}
if ((st_name = uilib_select_file(hwnd, translate_text(cartridges[i].title),
cartridges[i].filter, UILIB_SELECTOR_TYPE_FILE_LOAD,
UILIB_SELECTOR_STYLE_CART)) != NULL) {
char *name;
name = system_wcstombs_alloc(st_name);
if (cartridge_attach_image(cartridges[i].type, name) < 0)
ui_error(translate_text(IDS_INVALID_CARTRIDGE_IMAGE));
system_wcstombs_free(name);
lib_free(st_name);
}
}
/* FIXME: resetting the c64 should be handled in the upper layer */
static int set_mmc64_enabled(int val, void *param)
{
LOG(("MMC64: set_enabled: '%s' %d to %d", mmc64_bios_filename, mmc64_enabled, val));
if (!mmc64_enabled && val) {
/* activate mmc64 */
if (param) {
/* if the param is != NULL, then we should load the default image file */
LOG(("MMC64: set_enabled(1) '%s'", mmc64_bios_filename));
if (mmc64_bios_filename) {
if (*mmc64_bios_filename) {
if (cartridge_attach_image(CARTRIDGE_MMC64, mmc64_bios_filename) < 0) {
LOG(("MMC64: set_enabled(1) did not register"));
return -1;
}
/* mmc64_enabled = 1; */ /* cartridge_attach_image will end up calling set_mmc64_enabled again */
return 0;
}
}
} else {
LOG(("MMC64: set_enabled(0) '%s'", mmc64_bios_filename));
cart_power_off();
/* if the param is == NULL, then we should actually set the resource */
if (c64export_add(&export_res) < 0) {
LOG(("MMC64: set_enabled(0) did not register"));
return -1;
} else {
LOG(("MMC64: set_enabled registered"));
if (mmc64_activate() < 0) {
return -1;
}
mmc64_enabled = 1;
cart_set_port_exrom_slot0(1);
cart_port_config_changed_slot0();
mmc64_clockport_list_item = io_source_register(mmc64_current_clockport_device);
mmc64_io1_list_item = io_source_register(&mmc64_io1_device);
mmc64_io2_list_item = io_source_register(&mmc64_io2_device);
mmc64_reset();
}
}
} else if (mmc64_enabled && !val) {
/* remove mmc64 */
if (mmc64_deactivate() < 0) {
return -1;
}
cart_power_off();
c64export_remove(&export_res);
mmc64_enabled = 0;
cart_set_port_exrom_slot0(0);
cart_port_config_changed_slot0();
io_source_unregister(mmc64_clockport_list_item);
io_source_unregister(mmc64_io1_list_item);
io_source_unregister(mmc64_io2_list_item);
mmc64_clockport_list_item = NULL;
mmc64_io1_list_item = NULL;
mmc64_io2_list_item = NULL;
}
LOG(("MMC64: set_enabled done: '%s' %d : %d", mmc64_bios_filename, val, mmc64_enabled));
return 0;
}
static UI_CALLBACK(attach_cartridge)
{
int type = vice_ptr_to_int(UI_MENU_CB_PARAM);
char *filename;
ui_button_t button;
static char *last_dir;
uilib_file_filter_enum_t filter[] = { UILIB_FILTER_VIC20CART, UILIB_FILTER_ALL };
vsync_suspend_speed_eval();
filename = ui_select_file(_("Attach cartridge image"), NULL, 0, last_dir, filter, sizeof(filter) / sizeof(*filter), &button, 0, NULL, UI_FC_LOAD);
switch (button) {
case UI_BUTTON_OK:
if (cartridge_attach_image(type, filename) < 0) {
ui_error(_("Invalid cartridge image"));
}
lib_free(last_dir);
util_fname_split(filename, &last_dir, NULL);
ui_update_menus();
break;
default:
/* Do nothing special. */
break;
}
lib_free(filename);
}
/* ------------------------------------------------------------------------- */
static int cartridge_attach_from_resource(int type, const char *filename)
{
if (vic20cart_type == CARTRIDGE_VIC20_GENERIC) {
/* special case handling for the multiple file generic type */
return generic_attach_from_resource(vic20cart_type, cartfile);
}
return cartridge_attach_image(vic20cart_type, cartfile);
}
static int set_cartridge_file_4(const char *name, void *param)
{
if (cartridge_file_4 != NULL && name != NULL
&& strcmp(name, cartridge_file_4) == 0)
return 0;
util_string_set(&cartridge_file_4, name);
util_string_set(&cartfile4, name);
return cartridge_attach_image(CARTRIDGE_VIC20_16KB_4000, cartfile4);
}
static int set_cartridge_file_B(const char *name, void *param)
{
if (cartridge_file_B != NULL && name != NULL
&& strcmp(name, cartridge_file_B) == 0)
return 0;
util_string_set(&cartridge_file_B, name);
util_string_set(&cartfileB, name);
return cartridge_attach_image(CARTRIDGE_VIC20_4KB_B000, cartfileB);
}
static int set_cartridge_file_A(const char *name, void *param)
{
if (cartridge_file_A != NULL && name != NULL
&& strcmp(name, cartridge_file_A) == 0)
return 0;
util_string_set(&cartridge_file_A, name);
util_string_set(&cartfileA, name);
return cartridge_attach_image(CARTRIDGE_VIC20_8KB_A000, cartfileA);
}
static void uic64cart_attach(video_canvas_t *canvas, int idm,
const uicart_params_t *cartridges)
{
if (idm == IDM_CART_ENABLE_EXPERT) {
if (cartridge_attach_image(CARTRIDGE_EXPERT, NULL) < 0)
ui_error(translate_text(IDMES_INVALID_CART));
return;
}
uicart_attach(canvas, idm, cartridges);
}
static int try_cartridge_attach(int type, const char *filename)
{
int crtid;
if (filename) {
if (util_file_exists(filename)) {
if ((crtid = crt_getid(filename)) > 0) {
cartridge_type = CARTRIDGE_CRT; /* resource value modified */
return cartridge_attach_image(CARTRIDGE_CRT, filename);
} else if ((type != CARTRIDGE_NONE) && (type != CARTRIDGE_CRT)) {
cartridge_type = type; /* resource value modified */
return cartridge_attach_image(type, filename);
}
} else {
DBG(("cartridge_file does not exist: '%s'\n", filename));
}
}
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 void uic64cart_attach(WPARAM wparam, HWND hwnd,
const uicart_params_t *cartridges)
{
if (wparam == IDM_CART_ENABLE_EXPERT) {
if (cartridge_attach_image(CARTRIDGE_EXPERT, NULL) < 0)
ui_error(translate_text(IDS_INVALID_CARTRIDGE));
return;
}
uicart_attach(wparam, hwnd, cartridges);
}
static void cbm2_cart_attach(video_canvas_t *canvas, int cart_type)
{
char *fname;
fname = BrowseFile(translate_text(IDS_ATTACH_CART), "#?", canvas);
if (fname != NULL) {
if (cartridge_attach_image(cart_type, fname) < 0) {
ui_error(translate_text(IDMES_INVALID_CART_IMAGE));
}
}
}
/* Autostart `file_name', trying to auto-detect its type. */
int autostart_autodetect(const char *file_name, const char *program_name,
unsigned int program_number, unsigned int runmode)
{
if (network_connected() || event_record_active() || event_playback_active()
|| file_name == NULL) {
return -1;
}
if (!autostart_enabled) {
log_error(autostart_log,
"Autostart is not available on this setup.");
return -1;
}
log_message(autostart_log, "Autodetecting image type of `%s'.", file_name);
if (autostart_disk(file_name, program_name, program_number, runmode) == 0) {
log_message(autostart_log, "`%s' recognized as disk image.", file_name);
return 0;
}
if (machine_class != VICE_MACHINE_C64DTV && machine_class != VICE_MACHINE_SCPU64) {
if (autostart_tape(file_name, program_name, program_number, runmode) == 0) {
log_message(autostart_log, "`%s' recognized as tape image.", file_name);
return 0;
}
}
if (autostart_snapshot(file_name, program_name) == 0) {
log_message(autostart_log, "`%s' recognized as snapshot image.",
file_name);
return 0;
}
if ((machine_class == VICE_MACHINE_C64) || (machine_class == VICE_MACHINE_C64SC) ||
(machine_class == VICE_MACHINE_SCPU64) ||(machine_class == VICE_MACHINE_C128)) {
if (cartridge_attach_image(CARTRIDGE_CRT, file_name) == 0) {
log_message(autostart_log, "`%s' recognized as cartridge image.",
file_name);
return 0;
}
}
if (autostart_prg(file_name, runmode) == 0) {
log_message(autostart_log, "`%s' recognized as program/p00 file.",
file_name);
return 0;
}
log_error(autostart_log, "`%s' is not a valid file.", file_name);
return -1;
}
static UI_MENU_CALLBACK(attach_cart_callback)
{
char *name;
if (activated) {
name = sdl_ui_file_selection_dialog("Select Cart image", FILEREQ_MODE_CHOOSE_FILE);
if (name != NULL) {
if (cartridge_attach_image(vice_ptr_to_int(param), name) < 0) {
ui_error("Cannot load cartridge image.");
}
lib_free(name);
}
}
return NULL;
}
static TUI_MENU_CALLBACK(attach_cartridge_callback)
{
if (been_activated) {
char *name;
int type = (int)param;
name = tui_file_selector("Attach cartridge image", NULL, "*", NULL, NULL, NULL, NULL);
if (name != NULL && cartridge_attach_image(type, name) < 0) {
tui_error("Invalid cartridge image.");
}
ui_update_menus();
lib_free(name);
}
return NULL;
}
static UI_MENU_CALLBACK(attach_cart_callback)
{
char *title;
char *name = NULL;
if (activated) {
switch (vice_ptr_to_int(param)) {
case CARTRIDGE_VIC20_FP:
title = "Select " CARTRIDGE_VIC20_NAME_FP " image";
break;
case CARTRIDGE_VIC20_MEGACART:
title = "Select " CARTRIDGE_VIC20_NAME_MEGACART " image";
break;
case CARTRIDGE_VIC20_FINAL_EXPANSION:
title = "Select " CARTRIDGE_VIC20_NAME_FP " image";
break;
case CARTRIDGE_VIC20_DETECT:
case CARTRIDGE_VIC20_GENERIC:
title = "Select cartridge image";
break;
case CARTRIDGE_VIC20_16KB_2000:
case CARTRIDGE_VIC20_16KB_4000:
case CARTRIDGE_VIC20_16KB_6000:
title = "Select 4/8/16kB image";
break;
case CARTRIDGE_VIC20_8KB_A000:
title = "Select 4/8kB image";
break;
case CARTRIDGE_VIC20_4KB_B000:
default:
title = "Select 4kB image";
break;
}
name = sdl_ui_file_selection_dialog(title, FILEREQ_MODE_CHOOSE_FILE);
if (name != NULL) {
if (cartridge_attach_image(vice_ptr_to_int(param), name) < 0) {
ui_error("Cannot load cartridge image.");
}
lib_free(name);
}
}
return NULL;
}
static TUI_MENU_CALLBACK(attach_cartridge_callback)
{
if (been_activated) {
char *default_item, *directory;
char *name;
const char *s, *filter;
int type = (int)param;
s = cartridge_get_file_name((WORD)0);
util_fname_split(s, &directory, &default_item);
filter = (type == CARTRIDGE_CRT) ? "*.crt" : "*";
name = tui_file_selector("Attach cartridge image", directory, filter, default_item, NULL, NULL, NULL);
if (name != NULL && (s == NULL || strcasecmp(name, s) != 0) && cartridge_attach_image(type, name) < 0) {
tui_error("Invalid cartridge image.");
}
ui_update_menus();
lib_free(name);
}
return NULL;
}
void c64ui_attach_cart(char *imagefile, int carttype)
{
cartridge_attach_image(0, imagefile);
}
/**
* 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;
}
}
*/
}
static int attach_cart2(const char *param, void *extra_param)
{
return cartridge_attach_image(CARTRIDGE_VIC20_16KB_2000, param);
}
static int attach_cartridge_cmdline(const char *param, void *extra_param)
{
return cartridge_attach_image(vice_ptr_to_int(extra_param), 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;
}
