static TUI_MENU_CALLBACK(toggle_write_p00_callback)
{
int drive = (int)param;
int write_p00;
if (been_activated) {
resources_get_int_sprintf("FSDevice%iSaveP00", &write_p00, drive);
resources_set_int_sprintf("FSDevice%iSaveP00", !write_p00, drive);
ui_update_menus();
}
resources_get_int_sprintf("FSDevice%iSaveP00", &write_p00, drive);
return (write_p00) ? "On" : "Off";
}
static TUI_MENU_CALLBACK(toggle_hide_p00_callback)
{
int drive = (int)param;
int hide_p00;
if (been_activated) {
resources_get_int_sprintf("FSDevice%iHideCBMFiles", &hide_p00, drive);
resources_set_int_sprintf("FSDevice%iHideCBMFiles", !hide_p00, drive);
ui_update_menus();
}
resources_get_int_sprintf("FSDevice%iHideCBMFiles", &hide_p00, drive);
return (hide_p00) ? "On" : "Off";
}
char *romset_file_list(const char **resource_list)
{
char *list;
const char *s;
list = lib_stralloc("");
s = *resource_list++;
while (s != NULL) {
int enable;
char *line;
resources_get_int_sprintf("Romset%s", &enable, s);
if (enable != 0) {
line = resources_write_item_to_string(s, ARCHDEP_LINE_DELIMITER);
if (line != NULL)
util_addline_free(&list, line);
}
s = *resource_list++;
}
return list;
}
static TUI_MENU_CALLBACK(current_extend_string_callback)
{
int drive = (int)param;
int type = get_drive_type(drive);
int extend_support = drive_check_extend_policy(type);
int res_value;
char *s;
if (!extend_support) {
return "N/A";
}
resources_get_int_sprintf("Drive%iExtendImagePolicy", &res_value, drive);
switch (res_value) {
case DRIVE_EXTEND_NEVER:
default:
s = "Never extend";
break;
case DRIVE_EXTEND_ASK:
s = "Ask to extend";
break;
case DRIVE_EXTEND_ACCESS:
s = "Extend on access";
break;
}
return s;
}
static TUI_MENU_CALLBACK(current_idle_string_callback)
{
int drive = (int)param;
int type = get_drive_type(drive);
int idle_support = drive_check_idle_method(type);
int res_value;
char *s;
if (!idle_support) {
return "N/A";
}
resources_get_int_sprintf("Drive%iIdleMethod", &res_value, drive);
switch (res_value) {
default:
case DRIVE_IDLE_NO_IDLE:
s = "None";
break;
case DRIVE_IDLE_SKIP_CYCLES:
s = "Skip cycles";
break;
case DRIVE_IDLE_TRAP_IDLE:
s = "Trap idle";
break;
}
return s;
}
static int get_drive_type(int drive)
{
int iecdevice = 0;
int fsdevice;
int drivetype;
if (has_fs()) {
resources_get_int_sprintf("IECDevice%i", &iecdevice, drive);
resources_get_int_sprintf("FileSystemDevice%i", &fsdevice, drive);
}
resources_get_int_sprintf("Drive%iType", &drivetype, drive);
if (iecdevice) {
return fsdevice;
} else {
return drivetype;
}
}
static int get_drive_res(char *format, int drive)
{
int val;
resources_get_int_sprintf(format, &val, drive + 8);
return val;
}
static TUI_MENU_CALLBACK(radio_expansion_check_callback)
{
int drive = (int)param >> 16;
int value = (int)param & 0xffff;
int type = get_drive_type(drive);
int ram_support;
int res_value;
int i;
for (i = 0; uidrives[i].type != type; i++) {}
switch (value) {
default:
case 0x2000:
ram_support = uidrives[i].ram2000;
break;
case 0x4000:
ram_support = uidrives[i].ram4000;
break;
case 0x6000:
ram_support = uidrives[i].ram6000;
break;
case 0x8000:
ram_support = uidrives[i].ram8000;
break;
case 0xA000:
ram_support = uidrives[i].rama000;
break;
}
if (!ram_support) {
return "N/A";
}
if (been_activated) {
resources_get_int_sprintf("Drive%iRAM%X", &res_value, drive, value);
resources_set_int_sprintf("Drive%iRAM%X", !res_value, drive, value);
ui_update_menus();
}
resources_get_int_sprintf("Drive%iRAM%X", &res_value, drive, value);
return (res_value) ? "On" : "Off";
}
static TUI_MENU_CALLBACK(toggle_par_callback)
{
int drive = (int)param;
int type = get_drive_type(drive);
int par_support = drive_check_parallel_cable(type);
int par;
if (!par_support || machine_class == VICE_MACHINE_VIC20) {
return "N/A";
}
if (been_activated) {
resources_get_int_sprintf("Drive%iParallelCable", &par, drive);
resources_set_int_sprintf("Drive%iParallelCable", !par, drive);
ui_update_menus();
}
resources_get_int_sprintf("Drive%iParallelCable", &par, drive);
return (par) ? "On" : "Off";
}
static UI_CALLBACK(set_heads)
{
static char input_string[32];
int num = vice_ptr_to_int(UI_MENU_CB_PARAM);
if (CHECK_MENUS) {
int autosize;
resources_get_int_sprintf("IDE64AutodetectSize%i", &autosize, num);
if (autosize) {
ui_menu_set_sensitive(w, 0);
} else {
ui_menu_set_sensitive(w, 1);
}
} else {
char *msg_string;
ui_button_t button;
int i;
int heads;
vsync_suspend_speed_eval();
resources_get_int_sprintf("IDE64Heads%i", &heads, num);
sprintf(input_string, "%d", heads);
msg_string = lib_stralloc(_("Enter number of heads"));
button = ui_input_string(_("Heads"), msg_string, input_string, 32);
lib_free(msg_string);
if (button == UI_BUTTON_OK) {
i = atoi(input_string);
if (heads > 0 && heads <= 16 && heads != i) {
resources_set_int_sprintf("IDE64Heads%i", i, num);
ui_update_menus();
}
}
}
}
static int check_current_drive_type(int type, int drive)
{
int iecdevice = 0;
int fsdevice;
int drivetype;
if (has_fs()) {
resources_get_int_sprintf("IECDevice%i", &iecdevice, drive);
resources_get_int_sprintf("FileSystemDevice%i", &fsdevice, drive);
}
resources_get_int_sprintf("Drive%iType", &drivetype, drive);
if (iecdevice) {
if (type == fsdevice) {
return 1;
}
} else {
if (type == drivetype) {
return 1;
}
}
return 0;
}
static UI_CALLBACK(set_cylinders)
{
static char input_string[32];
int num = (int)UI_MENU_CB_PARAM;
if (CHECK_MENUS) {
int autosize;
resources_get_int_sprintf("IDE64AutodetectSize%i", &autosize, num);
if (autosize) {
ui_menu_set_sensitive(w, 0);
} else {
ui_menu_set_sensitive(w, 1);
}
} else {
char *msg_string;
ui_button_t button;
int i;
int cylinders;
vsync_suspend_speed_eval();
resources_get_int_sprintf("IDE64Cylinders%i", &cylinders, num);
sprintf(input_string, "%d", cylinders);
msg_string = lib_stralloc(_("Enter number of cylinders"));
button = ui_input_string(_("Cylinders"), msg_string, input_string, 32);
lib_free(msg_string);
if (button == UI_BUTTON_OK) {
i = atoi(input_string);
if (cylinders > 0 && cylinders <= 1024 && cylinders != i) {
resources_set_int_sprintf("IDE64Cylinders%i", i, num);
ui_update_menus();
}
}
}
}
static UI_CALLBACK(parallel_cable_control)
{
if (!CHECK_MENUS) {
ui_update_menus();
} else {
int type;
resources_get_int_sprintf("Drive%iType", &type, vice_ptr_to_int(UI_MENU_CB_PARAM) + 8);
if (drive_check_parallel_cable(type)) {
ui_menu_set_sensitive(w, 1);
} else {
ui_menu_set_sensitive(w, 0);
}
}
}
static TUI_MENU_CALLBACK(ui_set_rpm_callback)
{
int num = (int)param;
if (been_activated) {
int current_rpm, value;
char buf[10];
resources_get_int_sprintf("Drive%iRPM", ¤t_rpm, num);
sprintf(buf, "%d", current_rpm);
if (tui_input_string("RPM", "Enter the RPM (multiplied by 1000):", buf, 10) == 0) {
value = atoi(buf);
resources_set_int_sprintf("Drive%iRPM", value, num);
} else {
return NULL;
}
}
return NULL;
}
static TUI_MENU_CALLBACK(ui_set_wobble_callback)
{
int num = (int)param;
if (been_activated) {
int current_wobble, value;
char buf[10];
resources_get_int_sprintf("Drive%iWobble", ¤t_wobble, num);
sprintf(buf, "%d", current_wobble);
if (tui_input_string("Wobble", "Enter the wobble:", buf, 10) == 0) {
value = atoi(buf);
resources_set_int_sprintf("Drive%iWobble", value, num);
} else {
return NULL;
}
}
return NULL;
}
static TUI_MENU_CALLBACK(radio_idle_check_callback)
{
int drive = (int)param >> 16;
int value = (int)param & 0xffff;
int type = get_drive_type(drive);
int idle_support = drive_check_idle_method(type);
int res_value;
if (!idle_support) {
return "N/A";
}
if (been_activated) {
resources_set_int_sprintf("Drive%iIdleMethod", value, drive);
*become_default = 1;
ui_update_menus();
} else {
resources_get_int_sprintf("Drive%iIdleMethod", &res_value, drive);
if (res_value == value) {
*become_default = 1;
}
}
}
int romset_file_save(const char *filename, const char **resource_list)
{
FILE *fp;
char *newname;
const char *s;
newname = util_add_extension_const(filename, "vrs");
fp = fopen(newname, MODE_WRITE_TEXT);
if (fp == NULL) {
log_warning(romset_log, "Could not open file '%s' for writing (%s)!",
newname, strerror(errno));
lib_free(newname);
return -1;
}
log_message(romset_log, "Saving ROM set to file '%s'", newname);
s = *resource_list++;
while (s != NULL) {
int enable;
resources_get_int_sprintf("Romset%s", &enable, s);
if (enable != 0)
resources_write_item_to_file(fp, s);
s = *resource_list++;
}
fclose(fp);
lib_free(newname);
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;
}
}
*/
}
static void init_dialog(HWND hwnd, int num)
{
int drive_type, drive_extend_image_policy, drive_idle_method, n;
int drive_true_emulation, iecdevice, enabled;
resources_get_int_sprintf("IECDevice%i", &iecdevice, num);
resources_get_int("DriveTrueEmulation", &drive_true_emulation);
enabled = drive_true_emulation && !iecdevice;
EnableWindow(GetDlgItem(hwnd, IDC_SELECT_DRIVE_TYPE_1541),
enabled && drive_check_type(DRIVE_TYPE_1541, num - 8));
EnableWindow(GetDlgItem(hwnd, IDC_SELECT_DRIVE_TYPE_1541II),
enabled && drive_check_type(DRIVE_TYPE_1541II, num - 8));
EnableWindow(GetDlgItem(hwnd, IDC_SELECT_DRIVE_TYPE_1551),
enabled && drive_check_type(DRIVE_TYPE_1551, num - 8));
EnableWindow(GetDlgItem(hwnd, IDC_SELECT_DRIVE_TYPE_1570),
enabled && drive_check_type(DRIVE_TYPE_1570, num - 8));
EnableWindow(GetDlgItem(hwnd, IDC_SELECT_DRIVE_TYPE_1571),
enabled && drive_check_type(DRIVE_TYPE_1571, num - 8));
EnableWindow(GetDlgItem(hwnd, IDC_SELECT_DRIVE_TYPE_1581),
enabled && drive_check_type(DRIVE_TYPE_1581, num - 8));
EnableWindow(GetDlgItem(hwnd, IDC_SELECT_DRIVE_TYPE_NONE),
enabled);
resources_get_int_sprintf("Drive%dType", &drive_type, num);
resources_get_int_sprintf("Drive%dExtendImagePolicy",
&drive_extend_image_policy, num);
resources_get_int_sprintf("Drive%dIdleMethod", &drive_idle_method, num);
switch (drive_type) {
case DRIVE_TYPE_NONE:
n = IDC_SELECT_DRIVE_TYPE_NONE;
break;
case DRIVE_TYPE_1541:
n = IDC_SELECT_DRIVE_TYPE_1541;
break;
case DRIVE_TYPE_1541II:
n = IDC_SELECT_DRIVE_TYPE_1541II;
break;
case DRIVE_TYPE_1551:
n = IDC_SELECT_DRIVE_TYPE_1551;
break;
case DRIVE_TYPE_1570:
n = IDC_SELECT_DRIVE_TYPE_1570;
break;
case DRIVE_TYPE_1571:
n = IDC_SELECT_DRIVE_TYPE_1571;
break;
case DRIVE_TYPE_1581:
n = IDC_SELECT_DRIVE_TYPE_1581;
break;
}
if( !enabled )
n = IDC_SELECT_DRIVE_TYPE_NONE;
CheckRadioButton(hwnd, IDC_SELECT_DRIVE_TYPE_1541,
IDC_SELECT_DRIVE_TYPE_NONE, n);
enable_controls_for_drive_settings(hwnd, n);
switch (drive_extend_image_policy) {
case DRIVE_EXTEND_NEVER:
n = IDC_SELECT_DRIVE_EXTEND_NEVER;
break;
case DRIVE_EXTEND_ASK:
n = IDC_SELECT_DRIVE_EXTEND_ASK;
break;
case DRIVE_EXTEND_ACCESS:
n = IDC_SELECT_DRIVE_EXTEND_ACCESS;
break;
}
CheckRadioButton(hwnd, IDC_SELECT_DRIVE_EXTEND_NEVER,
IDC_SELECT_DRIVE_EXTEND_ACCESS, n);
switch (drive_idle_method) {
case DRIVE_IDLE_NO_IDLE:
n = IDC_SELECT_DRIVE_IDLE_NO_IDLE;
break;
case DRIVE_IDLE_TRAP_IDLE:
n = IDC_SELECT_DRIVE_IDLE_TRAP_IDLE;
break;
case DRIVE_IDLE_SKIP_CYCLES:
n = IDC_SELECT_DRIVE_IDLE_SKIP_CYCLES;
break;
}
CheckRadioButton(hwnd, IDC_SELECT_DRIVE_IDLE_NO_IDLE,
IDC_SELECT_DRIVE_IDLE_SKIP_CYCLES, n);
resources_get_int_sprintf("Drive%dParallelCable", &n, num);
CheckDlgButton(hwnd, IDC_TOGGLE_DRIVE_PARALLEL_CABLE, n
? BST_CHECKED : BST_UNCHECKED);
resources_get_int_sprintf("Drive%dRAM2000", &n, num);
CheckDlgButton(hwnd, IDC_TOGGLE_DRIVE_EXPANSION_2000, n
? BST_CHECKED : BST_UNCHECKED);
resources_get_int_sprintf("Drive%dRAM4000", &n, num);
CheckDlgButton(hwnd, IDC_TOGGLE_DRIVE_EXPANSION_4000, n
? BST_CHECKED : BST_UNCHECKED);
resources_get_int_sprintf("Drive%dRAM6000", &n, num);
CheckDlgButton(hwnd, IDC_TOGGLE_DRIVE_EXPANSION_6000, n
? BST_CHECKED : BST_UNCHECKED);
resources_get_int_sprintf("Drive%dRAM8000", &n, num);
CheckDlgButton(hwnd, IDC_TOGGLE_DRIVE_EXPANSION_8000, n
? BST_CHECKED : BST_UNCHECKED);
resources_get_int_sprintf("Drive%dRAMA000", &n, num);
CheckDlgButton(hwnd, IDC_TOGGLE_DRIVE_EXPANSION_A000, n
? BST_CHECKED : BST_UNCHECKED);
}
static void init_printer_dialog(unsigned int num, HWND hwnd)
{
HWND printer_hwnd;
int i, res_value, res_value_loop;
char printer_name[30];
const char *res_string;
int current = 0;
int xmax;
int xpos;
int size;
const int *ui_printer =
#ifdef HAVE_OPENCBM
(opencbmlib_is_available()) ? ui_printer_opencbm :
#endif
ui_printer_normal;
/* translate all dialog items */
uilib_localize_dialog(hwnd, printer_dialog_trans);
if (num != 0) {
/* translate the iec dialog item(s) */
uilib_localize_dialog(hwnd, printer_iec_dialog_trans);
}
/* adjust the size of the elements in the left group */
uilib_adjust_group_width(hwnd, printer_left_group);
/* get the max x of the bottom right group */
uilib_get_group_max_x(hwnd, printer_bottom_right_group, &xmax);
/* get the size of one of the elements of the bottom right group */
uilib_get_element_size(hwnd, IDC_PRINTER_OUTPUT_FILE3_NAME, &size);
/* get the max x of the left group */
uilib_get_group_max_x(hwnd, printer_left_group, &xpos);
/* move the top right group to the correct position */
uilib_move_group(hwnd, printer_top_right_group, xpos + 10);
/* move the bottom right group to the correct position */
uilib_move_group(hwnd, printer_bottom_right_group, xpos + 10);
/* get the max x of the bottom right group */
uilib_get_group_max_x(hwnd, printer_bottom_right_group, &xpos);
/* set the size of the bottom right group */
uilib_set_group_width(hwnd, printer_bottom_right_group, size + xpos - xmax);
/* get the max x of the printer emulation drop down element */
uilib_get_element_max_x(hwnd, IDC_PRINTER_TYPE, &xpos);
/* adjust the size of the elements in formfeed group */
uilib_adjust_group_width(hwnd, formfeed_group);
/* move the send formfeed button */
uilib_move_element(hwnd, IDC_PRINTER_FORMFEED, xpos + 10);
if (num == 0) {
sprintf(printer_name, "PrinterUserport");
} else {
sprintf(printer_name, "Printer%d", num);
}
resources_get_int(printer_name, &res_value);
printer_hwnd = GetDlgItem(hwnd, IDC_PRINTER_TYPE);
for (res_value_loop = 0; ui_printer[res_value_loop]; res_value_loop++) {
SendMessage(printer_hwnd, CB_ADDSTRING, 0, (LPARAM)translate_text(ui_printer[res_value_loop]));
}
SendMessage(printer_hwnd, CB_SETCURSEL, (WPARAM)res_value, 0);
resources_get_string_sprintf("%sDriver", &res_string, printer_name);
printer_hwnd = GetDlgItem(hwnd, IDC_PRINTER_DRIVER);
if (num == 6) {
for (res_value_loop = 0; ui_plotter_driver[res_value_loop]; res_value_loop++) {
SendMessage(printer_hwnd, CB_ADDSTRING, 0, (LPARAM)ui_plotter_driver[res_value_loop]);
if (!strcmp(ui_plotter_driver_1520[res_value_loop], res_string)) {
current = res_value_loop;
}
}
} else {
if (num == 0) {
for (res_value_loop = 0; ui_userprinter_driver[res_value_loop]; res_value_loop++) {
SendMessage(printer_hwnd, CB_ADDSTRING, 0, (LPARAM)ui_userprinter_driver[res_value_loop]);
if (!strcmp(ui_userprinter_driver_ascii[res_value_loop], res_string)) {
current = res_value_loop;
}
}
} else {
for (res_value_loop = 0; ui_printer_driver[res_value_loop]; res_value_loop++) {
SendMessage(printer_hwnd, CB_ADDSTRING, 0, (LPARAM)ui_printer_driver[res_value_loop]);
if (!strcmp(ui_printer_driver_ascii[res_value_loop], res_string)) {
current = res_value_loop;
}
}
}
}
SendMessage(printer_hwnd, CB_SETCURSEL, (WPARAM)current, 0);
resources_get_string_sprintf("%sOutput", &res_string, printer_name);
printer_hwnd = GetDlgItem(hwnd, IDC_PRINTER_OUTPUT);
for (res_value_loop = 0; ui_printer_output[res_value_loop]; res_value_loop++) {
SendMessage(printer_hwnd, CB_ADDSTRING, 0, (LPARAM)ui_printer_output[res_value_loop]);
if (!strcmp(ui_printer_output_ascii[res_value_loop], res_string)) {
current = res_value_loop;
}
}
SendMessage(printer_hwnd, CB_SETCURSEL, (WPARAM)current, 0);
resources_get_int_sprintf("%sTextDevice", &res_value, printer_name);
printer_hwnd = GetDlgItem(hwnd, IDC_PRINTER_TEXTOUT);
for (res_value_loop = 0; ui_printer_text_device[res_value_loop]; res_value_loop++) {
SendMessage(printer_hwnd, CB_ADDSTRING, 0, (LPARAM)ui_printer_text_device[res_value_loop]);
}
SendMessage(printer_hwnd, CB_SETCURSEL, (WPARAM)res_value, 0);
if (num > 0 && (iec_available_busses() & IEC_BUS_IEC)) {
resources_get_int_sprintf("IECDevice%d", &res_value, num);
CheckDlgButton(hwnd, IDC_PRINTER_USEIECDEVICE, res_value ? BST_CHECKED : BST_UNCHECKED);
} else {
ShowWindow(GetDlgItem(hwnd, IDC_PRINTER_USEIECDEVICE), FALSE);
CheckDlgButton(hwnd, IDC_PRINTER_USEIECDEVICE, BST_UNCHECKED);
}
for (i = 0; i < 3; i++) {
resources_get_string_sprintf("PrinterTextDevice%d", &res_string, i + 1);
if (res_string) {
strncpy(printertextdevice[i], res_string, MAX_PATH);
}
}
enable_printer_controls(num, hwnd);
}
static void init_dialog(HWND hwnd, unsigned int num)
{
const char *disk_image, *dir;
TCHAR *st_disk_image, *st_dir;
int devtype, n;
int xpos, xpos1, xpos2, xpos3;
int distance1, distance2;
RECT rect;
uilib_localize_dialog_param *diskdevice_dialog =
#ifdef HAVE_OPENCBM
(opencbmlib_is_available()) ? diskdevice_opencbm_dialog :
#endif
diskdevice_normal_dialog;
if (num >= 8 && num <= 11) {
/* translate all dialog items */
uilib_localize_dialog(hwnd, diskdevice_dialog);
/* adjust the size of the elements in the diskdevice_left_group */
uilib_adjust_group_width(hwnd, diskdevice_left_group);
/* adjust the size of the 'read-only' element */
uilib_adjust_group_width(hwnd, diskdevice_read_only);
/* get the min x of the read only element */
uilib_get_element_min_x(hwnd, IDC_TOGGLE_ATTACH_READONLY, &xpos3);
/* get the min x of the autostart element */
uilib_get_element_min_x(hwnd, IDC_AUTOSTART, &xpos2);
/* get the max x of the first browse element */
uilib_get_element_max_x(hwnd, IDC_BROWSEDISK, &xpos1);
/* calculate the distance between the browse button and the autostart button */
distance1 = xpos2 - xpos1;
/* get the max x of the autostart element */
uilib_get_element_max_x(hwnd, IDC_AUTOSTART, &xpos2);
/* calculate the distance between the browse button and the read only element */
distance2 = xpos3 - xpos2;
/* get the max x of the disk_device_left_group items */
uilib_get_group_max_x(hwnd, diskdevice_left_group, &xpos);
/* move the filename elements and browse buttons to the right position */
uilib_move_group(hwnd, diskdevice_middle_group, xpos + 10);
/* get the max x of the first browse element */
uilib_get_element_max_x(hwnd, IDC_BROWSEDISK, &xpos);
/* move the autostart element to the right position */
uilib_move_element(hwnd, IDC_AUTOSTART, xpos + distance1);
/* resize the autostart element */
uilib_adjust_element_width(hwnd, IDC_AUTOSTART);
/* get the max x of the autostart element */
uilib_get_element_max_x(hwnd, IDC_AUTOSTART, &xpos);
/* move the read only element to the right position */
uilib_move_element(hwnd, IDC_TOGGLE_ATTACH_READONLY, xpos + distance2);
#ifdef HAVE_OPENCBM
if (opencbmlib_is_available()) {
/* adjust the size of the real iec element */
uilib_adjust_element_width(hwnd, IDC_SELECTREAL);
/* get the max x of the real iec element */
uilib_get_element_max_x(hwnd, IDC_SELECTREAL, &xpos1);
} else {
xpos1 = 0;
}
#else
xpos1 = 0;
#endif
/* get the max x of the second browse button */
uilib_get_element_max_x(hwnd, IDC_BROWSEDIR, &xpos2);
if (xpos2 > xpos1) {
xpos = xpos2 + 20;
} else {
xpos = xpos1 + 20;
}
/* move the diskdevice_right_group to the right position */
uilib_move_group(hwnd, diskdevice_right_group, xpos);
/* move the p00 group element to the right position */
uilib_move_element(hwnd, IDC_DISKDEVICE_OPTIONS, xpos - 5);
/* adjust the diskdevice_right_group elements size */
uilib_adjust_group_width(hwnd, diskdevice_right_group);
/* adjust the p00 group element size */
uilib_adjust_element_width(hwnd, IDC_DISKDEVICE_OPTIONS);
/* get the width of the disk_device_right_group items */
uilib_get_group_width(hwnd, diskdevice_right_group, &xpos1);
/* get the width of the p00 group element */
uilib_get_element_width(hwnd, IDC_DISKDEVICE_OPTIONS, &xpos2);
if (xpos2 + 5 > xpos1) {
xpos = xpos2 + 15;
} else {
xpos = xpos1 + 10;
}
/* set the width of the p00 group element */
uilib_set_element_width(hwnd, IDC_DISKDEVICE_OPTIONS, xpos);
/* adjust the none element size */
uilib_adjust_element_width(hwnd, IDC_SELECTNONE);
/* adjust the size of the use iec device element */
uilib_adjust_element_width(hwnd, IDC_TOGGLE_USEIECDEVICE);
/* get the max x of the window filling elements */
uilib_get_group_max_x(hwnd, diskdevice_filling_group, &xpos);
/* set the width of the dialog to 'surround' all the elements */
GetWindowRect(hwnd, &rect);
MoveWindow(hwnd, rect.left, rect.top, xpos + 10, rect.bottom - rect.top, TRUE);
disk_image = file_system_get_disk_name(num);
st_disk_image = system_mbstowcs_alloc(disk_image);
SetDlgItemText(hwnd, IDC_DISKIMAGE, st_disk_image != NULL ? st_disk_image : TEXT(""));
system_mbstowcs_free(st_disk_image);
resources_get_string_sprintf("FSDevice%dDir", &dir, num);
st_dir = system_mbstowcs_alloc(dir);
SetDlgItemText(hwnd, IDC_DIR, st_dir != NULL ? st_dir : TEXT(""));
system_mbstowcs_free(st_dir);
resources_get_int_sprintf("FSDevice%dConvertP00", &n, num);
CheckDlgButton(hwnd, IDC_TOGGLE_READP00, n ? BST_CHECKED : BST_UNCHECKED);
resources_get_int_sprintf("FSDevice%dSaveP00", &n, num);
CheckDlgButton(hwnd, IDC_TOGGLE_WRITEP00, n ? BST_CHECKED : BST_UNCHECKED);
resources_get_int_sprintf("FSDevice%dHideCBMFiles", &n, num);
CheckDlgButton(hwnd, IDC_TOGGLE_HIDENONP00, n ? BST_CHECKED : BST_UNCHECKED);
resources_get_int_sprintf("AttachDevice%dReadonly", &n, num);
CheckDlgButton(hwnd, IDC_TOGGLE_ATTACH_READONLY, n ? BST_CHECKED : BST_UNCHECKED);
resources_get_int_sprintf("FileSystemDevice%d", &devtype, num);
switch (devtype) {
case ATTACH_DEVICE_FS:
if (disk_image != NULL) {
n = IDC_SELECTDISK;
} else {
n = IDC_SELECTDIR;
}
break;
#ifdef HAVE_OPENCBM
case ATTACH_DEVICE_REAL:
n = IDC_SELECTREAL;
break;
#endif
default:
n = IDC_SELECTNONE;
}
#ifdef HAVE_OPENCBM
if (opencbmlib_is_available()) {
CheckRadioButton(hwnd, IDC_SELECTDISK, IDC_SELECTREAL, n);
} else {
CheckRadioButton(hwnd, IDC_SELECTDISK, IDC_SELECTDIR, n);
}
#else
CheckRadioButton(hwnd, IDC_SELECTDISK, IDC_SELECTDIR, n);
#endif
enable_controls_for_disk_device_type(hwnd, n);
if (iec_available_busses() & IEC_BUS_IEC) {
resources_get_int_sprintf("IECDevice%d", &n, num);
CheckDlgButton(hwnd, IDC_TOGGLE_USEIECDEVICE, n ? BST_CHECKED : BST_UNCHECKED);
} else {
CheckDlgButton(hwnd, IDC_TOGGLE_USEIECDEVICE, BST_UNCHECKED);
ShowWindow(GetDlgItem(hwnd, IDC_TOGGLE_USEIECDEVICE), FALSE);
}
enable_controls(hwnd);
}
}
int get_drive_type(int drive,int val)
{
return resources_get_int_sprintf("Drive%iType",drive);
}
static void init_dialog(HWND hwnd, int num)
{
int drive_type, drive_extend_image_policy, drive_idle_method, n;
int drive_true_emulation, iecdevice, enabled;
int xpos;
int xstart;
HWND parent_hwnd;
HWND element;
parent_hwnd = GetParent(hwnd);
/* translate all dialog items */
uilib_localize_dialog(hwnd, drive_dialog_trans);
/* translate the parent window items */
uilib_localize_dialog(parent_hwnd, parent_dialog_trans);
/* translate the generic items */
for (n = 0; generic_items[n].text != NULL; n++) {
element = GetDlgItem(hwnd, generic_items[n].idm);
SetWindowText(element, generic_items[n].text);
}
/* adjust the size of the elements in the main group */
uilib_adjust_group_width(hwnd, drive_main_group);
/* get the max x of the elements in the left group */
uilib_get_group_max_x(hwnd, drive_left_group, &xpos);
/* get the min x of the none element of the left group */
uilib_get_element_min_x(hwnd, IDC_SELECT_DRIVE_TYPE_NONE, &xstart);
/* resize and move the left group element to the correct position */
uilib_move_and_set_element_width(hwnd, IDC_DRIVE_TYPE, xstart - 10, xpos - xstart + 20);
/* get the max x of the left group element */
uilib_get_element_max_x(hwnd, IDC_DRIVE_TYPE, &xpos);
/* move the middle group elements to the correct position */
uilib_move_group(hwnd, drive_middle_move_group, xpos + 20);
uilib_move_element(hwnd, IDC_40_TRACK_HANDLING, xpos + 10);
uilib_move_element(hwnd, IDC_DRIVE_EXPANSION, xpos + 10);
xstart = xpos + 20;
/* get the max x of the middle group */
uilib_get_group_max_x(hwnd, drive_middle_group, &xpos);
/* resize and move the middle group boxes to the correct position */
uilib_move_and_set_element_width(hwnd, IDC_40_TRACK_HANDLING, xstart - 10, xpos - xstart + 20);
uilib_move_and_set_element_width(hwnd, IDC_DRIVE_EXPANSION, xstart - 10, xpos - xstart + 20);
/* get the max x of the middle group element */
uilib_get_element_max_x(hwnd, IDC_DRIVE_EXPANSION, &xpos);
/* move the right group elements to the correct position */
uilib_move_group(hwnd, drive_right_move_group, xpos + 20);
uilib_move_element(hwnd, IDC_IDLE_METHOD, xpos + 10);
xstart = xpos + 20;
/* get the max x of the right group */
uilib_get_group_max_x(hwnd, drive_right_group, &xpos);
/* resize and move the right group element to the correct position */
uilib_move_and_set_element_width(hwnd, IDC_IDLE_METHOD, xstart - 10, xpos - xstart + 20);
/* recenter the buttons in the newly resized dialog window */
uilib_center_buttons(parent_hwnd, move_buttons_group, 0);
resources_get_int_sprintf("IECDevice%i", &iecdevice, num);
resources_get_int("DriveTrueEmulation", &drive_true_emulation);
enabled = drive_true_emulation && !iecdevice;
EnableWindow(GetDlgItem(hwnd, IDC_SELECT_DRIVE_TYPE_1540), enabled && drive_check_type(DRIVE_TYPE_1540, num - 8));
EnableWindow(GetDlgItem(hwnd, IDC_SELECT_DRIVE_TYPE_1541), enabled && drive_check_type(DRIVE_TYPE_1541, num - 8));
EnableWindow(GetDlgItem(hwnd, IDC_SELECT_DRIVE_TYPE_1541II), enabled && drive_check_type(DRIVE_TYPE_1541II, num - 8));
EnableWindow(GetDlgItem(hwnd, IDC_SELECT_DRIVE_TYPE_1570), enabled && drive_check_type(DRIVE_TYPE_1570, num - 8));
EnableWindow(GetDlgItem(hwnd, IDC_SELECT_DRIVE_TYPE_1571), enabled && drive_check_type(DRIVE_TYPE_1571, num - 8));
EnableWindow(GetDlgItem(hwnd, IDC_SELECT_DRIVE_TYPE_1581), enabled && drive_check_type(DRIVE_TYPE_1581, num - 8));
EnableWindow(GetDlgItem(hwnd, IDC_SELECT_DRIVE_TYPE_2000), enabled && drive_check_type(DRIVE_TYPE_2000, num - 8));
EnableWindow(GetDlgItem(hwnd, IDC_SELECT_DRIVE_TYPE_4000), enabled && drive_check_type(DRIVE_TYPE_4000, num - 8));
EnableWindow(GetDlgItem(hwnd, IDC_SELECT_DRIVE_TYPE_NONE), enabled);
resources_get_int_sprintf("Drive%dType", &drive_type, num);
resources_get_int_sprintf("Drive%dExtendImagePolicy", &drive_extend_image_policy, num);
resources_get_int_sprintf("Drive%dIdleMethod", &drive_idle_method, num);
dialog_drive_type[num - 8] = drive_type;
switch (drive_type) {
case DRIVE_TYPE_NONE:
n = IDC_SELECT_DRIVE_TYPE_NONE;
break;
case DRIVE_TYPE_1540:
n = IDC_SELECT_DRIVE_TYPE_1540;
break;
case DRIVE_TYPE_1541:
n = IDC_SELECT_DRIVE_TYPE_1541;
break;
case DRIVE_TYPE_1541II:
n = IDC_SELECT_DRIVE_TYPE_1541II;
break;
case DRIVE_TYPE_1570:
n = IDC_SELECT_DRIVE_TYPE_1570;
break;
case DRIVE_TYPE_1571:
n = IDC_SELECT_DRIVE_TYPE_1571;
break;
case DRIVE_TYPE_1581:
n = IDC_SELECT_DRIVE_TYPE_1581;
break;
case DRIVE_TYPE_2000:
n = IDC_SELECT_DRIVE_TYPE_2000;
break;
case DRIVE_TYPE_4000:
n = IDC_SELECT_DRIVE_TYPE_4000;
break;
}
if (!enabled) {
n = IDC_SELECT_DRIVE_TYPE_NONE;
}
CheckRadioButton(hwnd, IDC_SELECT_DRIVE_TYPE_1541, IDC_SELECT_DRIVE_TYPE_NONE, n);
enable_controls_for_drive_settings(hwnd, n);
dialog_drive_extend[num - 8] = drive_extend_image_policy;
switch (drive_extend_image_policy) {
case DRIVE_EXTEND_NEVER:
n = IDC_SELECT_DRIVE_EXTEND_NEVER;
break;
case DRIVE_EXTEND_ASK:
n = IDC_SELECT_DRIVE_EXTEND_ASK;
break;
case DRIVE_EXTEND_ACCESS:
n = IDC_SELECT_DRIVE_EXTEND_ACCESS;
break;
}
CheckRadioButton(hwnd, IDC_SELECT_DRIVE_EXTEND_NEVER, IDC_SELECT_DRIVE_EXTEND_ACCESS, n);
dialog_drive_idle[num - 8] = drive_idle_method;
switch (drive_idle_method) {
case DRIVE_IDLE_NO_IDLE:
n = IDC_SELECT_DRIVE_IDLE_NO_IDLE;
break;
case DRIVE_IDLE_TRAP_IDLE:
n = IDC_SELECT_DRIVE_IDLE_TRAP_IDLE;
break;
case DRIVE_IDLE_SKIP_CYCLES:
n = IDC_SELECT_DRIVE_IDLE_SKIP_CYCLES;
break;
}
CheckRadioButton(hwnd, IDC_SELECT_DRIVE_IDLE_NO_IDLE, IDC_SELECT_DRIVE_IDLE_SKIP_CYCLES, n);
resources_get_int_sprintf("Drive%dRAM2000", &n, num);
CheckDlgButton(hwnd, IDC_TOGGLE_DRIVE_EXPANSION_2000, n ? BST_CHECKED : BST_UNCHECKED);
resources_get_int_sprintf("Drive%dRAM4000", &n, num);
CheckDlgButton(hwnd, IDC_TOGGLE_DRIVE_EXPANSION_4000, n ? BST_CHECKED : BST_UNCHECKED);
resources_get_int_sprintf("Drive%dRAM6000", &n, num);
CheckDlgButton(hwnd, IDC_TOGGLE_DRIVE_EXPANSION_6000, n ? BST_CHECKED : BST_UNCHECKED);
resources_get_int_sprintf("Drive%dRAM8000", &n, num);
CheckDlgButton(hwnd, IDC_TOGGLE_DRIVE_EXPANSION_8000, n ? BST_CHECKED : BST_UNCHECKED);
resources_get_int_sprintf("Drive%dRAMA000", &n, num);
CheckDlgButton(hwnd, IDC_TOGGLE_DRIVE_EXPANSION_A000, n ? BST_CHECKED : BST_UNCHECKED);
resources_get_int_sprintf("Drive%dRTCSave", &n, num);
CheckDlgButton(hwnd, IDC_TOGGLE_DRIVE_RTC_SAVE, n ? BST_CHECKED : BST_UNCHECKED);
}
static void init_resources_dialog(HWND hwnd, unsigned int type)
{
unsigned int n = 0;
int xpos1, xpos2;
int size;
RECT rect;
int idc;
int i;
HWND element;
if (type == UIROM_TYPE_MAIN) {
/* translate all dialog items */
uilib_localize_dialog(hwnd, main_res_trans);
idc = IDC_COMPUTER_RESOURCES;
} else if (type == UIROM_TYPE_DRIVE) {
/* translate all dialog items */
uilib_localize_dialog(hwnd, drive_res_trans);
/* translate generic items */
for (i = 0; generic_res_trans[i].text != NULL; i++) {
element = GetDlgItem(hwnd, generic_res_trans[i].idm);
SetWindowText(element, generic_res_trans[i].text);
}
idc = IDC_DRIVE_RESOURCES;
}
/* get the max x of the group element */
uilib_get_element_max_x(hwnd, idc, &xpos1);
/* get the size of the group element */
uilib_get_element_size(hwnd, idc, &size);
/* adjust the size of the group element */
uilib_adjust_element_width(hwnd, idc);
/* get the max x of the group element */
uilib_get_element_max_x(hwnd, idc, &xpos2);
if (xpos2 < xpos1) {
/* restore the size of the group element */
uilib_set_element_width(hwnd, idc, size);
} else {
/* resize the dialog window */
GetWindowRect(hwnd, &rect);
MoveWindow(hwnd, rect.left, rect.top, xpos2 + 10, rect.bottom - rect.top, TRUE);
/* recenter the buttons in the newly resized dialog window */
uilib_center_buttons(hwnd, move_buttons_group, 0);
}
while (settings[n].realname != NULL) {
if (settings[n].type == type) {
int enable;
resources_get_int_sprintf("Romset%s", &enable, settings[n].resname);
CheckDlgButton(hwnd, settings[n].idc_resource, enable ? BST_CHECKED : BST_UNCHECKED);
}
n++;
}
}
static void init_dialog(HWND hwnd, int num)
{
int drive_type, drive_extend_image_policy, n = 0;
EnableWindow(GetDlgItem(hwnd, IDC_SELECT_DRIVE_TYPE_2031),
drive_check_type(DRIVE_TYPE_2031, num - 8));
EnableWindow(GetDlgItem(hwnd, IDC_SELECT_DRIVE_TYPE_2040),
drive_check_type(DRIVE_TYPE_2040, num - 8));
EnableWindow(GetDlgItem(hwnd, IDC_SELECT_DRIVE_TYPE_3040),
drive_check_type(DRIVE_TYPE_3040, num - 8));
EnableWindow(GetDlgItem(hwnd, IDC_SELECT_DRIVE_TYPE_4040),
drive_check_type(DRIVE_TYPE_4040, num - 8));
EnableWindow(GetDlgItem(hwnd, IDC_SELECT_DRIVE_TYPE_1001),
drive_check_type(DRIVE_TYPE_1001, num - 8));
EnableWindow(GetDlgItem(hwnd, IDC_SELECT_DRIVE_TYPE_8050),
drive_check_type(DRIVE_TYPE_8050, num - 8));
EnableWindow(GetDlgItem(hwnd, IDC_SELECT_DRIVE_TYPE_8250),
drive_check_type(DRIVE_TYPE_8250, num - 8));
resources_get_int_sprintf("Drive%dType", &drive_type, num);
resources_get_int_sprintf("Drive%dExtendImagePolicy",
&drive_extend_image_policy, num);
switch (drive_type) {
case DRIVE_TYPE_NONE:
n = IDC_SELECT_DRIVE_TYPE_NONE;
break;
case DRIVE_TYPE_2031:
n = IDC_SELECT_DRIVE_TYPE_2031;
break;
case DRIVE_TYPE_2040:
n = IDC_SELECT_DRIVE_TYPE_2040;
break;
case DRIVE_TYPE_3040:
n = IDC_SELECT_DRIVE_TYPE_3040;
break;
case DRIVE_TYPE_4040:
n = IDC_SELECT_DRIVE_TYPE_4040;
break;
case DRIVE_TYPE_1001:
n = IDC_SELECT_DRIVE_TYPE_1001;
break;
case DRIVE_TYPE_8050:
n = IDC_SELECT_DRIVE_TYPE_8050;
break;
case DRIVE_TYPE_8250:
n = IDC_SELECT_DRIVE_TYPE_8250;
break;
}
CheckRadioButton(hwnd, IDC_SELECT_DRIVE_TYPE_2031,
IDC_SELECT_DRIVE_TYPE_NONE, n);
enable_controls_for_drive_settings(hwnd, n);
switch (drive_extend_image_policy) {
case DRIVE_EXTEND_NEVER:
n = IDC_SELECT_DRIVE_EXTEND_NEVER;
break;
case DRIVE_EXTEND_ASK:
n = IDC_SELECT_DRIVE_EXTEND_ASK;
break;
case DRIVE_EXTEND_ACCESS:
n = IDC_SELECT_DRIVE_EXTEND_ACCESS;
break;
}
CheckRadioButton(hwnd, IDC_SELECT_DRIVE_EXTEND_NEVER,
IDC_SELECT_DRIVE_EXTEND_ACCESS, n);
}
