static TUI_MENU_CALLBACK(radio_type_check_callback)
{
int drive = (int)param >> 16;
int type = (int)param & 0xffff;
int value;
int i;
int support = (is_fs(type) || drive_check_type(type, drive - 8));
if (!support) {
return "N/A";
}
if (been_activated) {
if (is_fs(type)) {
resources_set_int_sprintf("IECDevice%i", 1, drive);
resources_set_int_sprintf("FileSystemDevice%i", type, drive);
} else {
if (has_fs()) {
resources_set_int_sprintf("IECDevice%i", 0, drive);
}
resources_set_int_sprintf("Drive%iType", type, drive);
}
*become_default = 1;
ui_update_menus();
} else {
if (check_current_drive_type(type, drive)) {
*become_default = 1;
}
}
}
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_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);
}
/* Initialize the hardware-level drive emulation (should be called at least
once before anything else). Return 0 on success, -1 on error. */
int drive_init(void)
{
unsigned int dnr;
drive_t *drive;
if (rom_loaded) {
return 0;
}
drive_init_was_called = 1;
driverom_init();
drive_image_init();
drive_log = log_open("Drive");
for (dnr = 0; dnr < DRIVE_NUM; dnr++) {
char *logname;
drive = drive_context[dnr]->drive;
logname = lib_msprintf("Drive %i", dnr + 8);
drive->log = log_open(logname);
lib_free(logname);
drive_clk[dnr] = 0L;
drive->clk = &drive_clk[dnr];
drive->mynumber = dnr;
}
if (driverom_load_images() < 0) {
resources_set_int("Drive8Type", DRIVE_TYPE_NONE);
resources_set_int("Drive9Type", DRIVE_TYPE_NONE);
resources_set_int("Drive10Type", DRIVE_TYPE_NONE);
resources_set_int("Drive11Type", DRIVE_TYPE_NONE);
return -1;
}
log_message(drive_log, "Finished loading ROM images.");
rom_loaded = 1;
drive_overflow_init();
for (dnr = 0; dnr < DRIVE_NUM; dnr++) {
drive = drive_context[dnr]->drive;
machine_drive_port_default(drive_context[dnr]);
if (drive_check_type(drive->type, dnr) < 1) {
resources_set_int_sprintf("Drive%iType", DRIVE_TYPE_NONE, dnr + 8);
}
machine_drive_rom_setup_image(dnr);
}
for (dnr = 0; dnr < DRIVE_NUM; dnr++) {
drive = drive_context[dnr]->drive;
drive->gcr = gcr_create_image();
drive->p64 = lib_calloc(1, sizeof(TP64Image));
P64ImageCreate(drive->p64);
drive->byte_ready_level = 1;
drive->byte_ready_edge = 1;
drive->GCR_dirty_track = 0;
drive->GCR_write_value = 0x55;
drive->GCR_track_start_ptr = NULL;
drive->GCR_current_track_size = 0;
drive->attach_clk = (CLOCK)0;
drive->detach_clk = (CLOCK)0;
drive->attach_detach_clk = (CLOCK)0;
drive->old_led_status = 0;
drive->old_half_track = 0;
drive->side = 0;
drive->GCR_image_loaded = 0;
drive->P64_image_loaded = 0;
drive->P64_dirty = 0;
drive->read_only = 0;
drive->clock_frequency = 1;
drive->led_last_change_clk = *(drive->clk);
drive->led_last_uiupdate_clk = *(drive->clk);
drive->led_active_ticks = 0;
rotation_reset(drive);
/* Position the R/W head on the directory track. */
drive_set_half_track(36, 0, drive);
drive_set_active_led_color(drive->type, dnr);
}
for (dnr = 0; dnr < DRIVE_NUM; dnr++) {
drive = drive_context[dnr]->drive;
driverom_initialize_traps(drive);
drivesync_clock_frequency(drive->type, drive);
rotation_init((drive->clock_frequency == 2) ? 1 : 0, dnr);
if (drive->type == DRIVE_TYPE_2000 || drive->type == DRIVE_TYPE_4000) {
drivecpu65c02_init(drive_context[dnr], drive->type);
} else {
drivecpu_init(drive_context[dnr], drive->type);
}
/* Make sure the sync factor is acknowledged correctly. */
drivesync_factor(drive_context[dnr]);
/* Make sure the traps are moved as needed. */
if (drive->enable) {
drive_enable(drive_context[dnr]);
}
}
return 0;
}
static MRESULT EXPENTRY pm_drive(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
static int drive = 0;
switch (msg) {
case WM_INITDLG:
{
int val, i = 0;
HWND ihwnd = WinWindowFromID(hwnd, CBS_IMAGE);
while (i < 10 && ui_status.imageHist[i][0]) {
WinLboxInsertItem(ihwnd, ui_status.imageHist[i++]);
}
WinLboxInsertItem(ihwnd, "");
resources_get_int("DriveTrueEmulation", &val);
WinCheckButton(hwnd, CB_TRUEDRIVE, val);
WinCheckButton(hwnd, RB_DRIVE8|drive, 1);
WinSendMsg(hwnd, WM_SWITCH, (void*)drive, 0);
WinSendMsg(hwnd, WM_DRIVESTATE, (void*)ui_status.lastDriveState, NULL);
for (i = 0; i < 3; i++) {
WinSendMsg(hwnd, WM_TRACK, (void*)i, (void*)(int)(ui_status.lastTrack[i] * 2));
}
}
break;
case WM_COMMAND:
switch (LONGFROMMP(mp1)) {
case PB_CREATE:
create_dialog(hwnd);
return FALSE;
case PB_ATTACH:
ViceFileDialog(hwnd, 0x0100 | (drive + 1), FDS_OPEN_DIALOG);
return FALSE;
case PB_DETACH:
file_system_detach_disk(drive + 8);
return FALSE;
case PB_FLIPADD:
fliplist_add_image(drive + 8);
return FALSE;
case PB_FLIPREMOVE:
fliplist_remove(drive + 8, NULL);
return FALSE;
case PB_FLIP:
fliplist_attach_head(drive + 8, FLIP_NEXT);
return FALSE;
}
break;
case WM_CONTROL:
{
switch (SHORT1FROMMP(mp1)) {
case RB_DRIVE8:
case RB_DRIVE9:
case RB_DRIVE10:
case RB_DRIVE11:
WinSendMsg(hwnd, WM_SWITCH, (void*)(SHORT1FROMMP(mp1) & 0x3), 0);
break;
case CB_TRUEDRIVE:
toggle("DriveTrueEmulation");
WinSendMsg(hwnd, WM_SWITCH, (void*)drive, 0);
break;
case CB_CONVERTP00:
toggle_drive_res("FSDevice%dConvertP00", drive);//);
WinSendMsg(hwnd, WM_SWITCH, (void*)drive, 0);
break;
case CB_SAVEP00:
toggle_drive_res("FileDevice%dSaveP00", drive);
break;
case CB_ALLOWACCESS:
toggle_drive_res("FileSystemDevice%d", drive);
WinSendMsg(hwnd, WM_SWITCH, (void*)drive, 0);
break;
case CB_HIDENONP00:
toggle_drive_res("FSDevice%dHideCBMFiles", drive);
break;
case CB_MEM2000:
toggle_drive_res("Drive%dRAM2000", drive);
break;
case CB_MEM4000:
toggle_drive_res("Drive%dRAM4000", drive);
break;
case CB_MEM6000:
toggle_drive_res("Drive%dRAM6000", drive);
break;
case CB_MEM8000:
toggle_drive_res("Drive%dRAM8000", drive);
break;
case CB_MEMA000:
toggle_drive_res("Drive%dRAMA000", drive);
break;
case CB_READONLY:
toggle_drive_res("AttachDevice%dReadonly", drive);
break;
case CB_PARALLEL:
if (drive == 0 || drive == 1) {
toggle_drive_res("Drive%dParallelCable", drive);
}
break;
case RB_NEVER:
case RB_ASK:
case RB_ALWAYS:
if (drive == 0 || drive == 1) {
resources_set_int_sprintf("Drive%dExtendImagePolicy", (SHORT1FROMMP(mp1) & 0x3), drive + 8);
}
break;
case RB_NONE:
case RB_TRAP:
case RB_SKIP:
if (drive == 0 || drive == 1) {
resources_set_int_sprintf("Drive%dIdleMethod", (SHORT1FROMMP(mp1) & 0x3), drive + 8);
}
break;
case CBS_IMAGE:
if (SHORT2FROMMP(mp1) == CBN_ENTER) {
char psz[CCHMAXPATH];
WinLboxQuerySelectedItemText(hwnd, CBS_IMAGE, psz, CCHMAXPATH);
if (!strlen(psz)) {
file_system_detach_disk(drive + 8);
return FALSE;
}
if (file_system_attach_disk(drive + 8, psz)) {
WinMessageBox(HWND_DESKTOP, hwnd, "Cannot attach specified file.", "VICE/2 Error", 0, MB_OK);
}
}
return FALSE;
case CBS_PATH:
switch (SHORT2FROMMP(mp1)) {
case SPBN_CHANGE:
{
char path[255];
WinSendDlgMsg(hwnd, CBS_PATH, SPBM_QUERYVALUE, &path, 255);
if (!chdir(path)) {
resources_set_string_sprintf("FSDevice%dDir", path, drive + 8);
}
}
break;
case SPBN_KILLFOCUS:
{
const char *path;
resources_get_string_sprintf("FSDevice%dDir", &path, drive + 8);
WinSendDlgMsg(hwnd, CBS_PATH, SPBM_SETARRAY, &path, 1);
WinSetDlgSpinVal(hwnd, CBS_PATH, 0);
}
break;
}
return FALSE;
case CBS_TYPE:
if (SHORT2FROMMP(mp1) == CBN_ENTER && (drive == 0 || drive == 1)) {
const int nr = WinQueryLboxSelectedItem((HWND)mp2);
const int val = WinLboxItemHandle((HWND)mp2, nr);
resources_set_int_sprintf("Drive%dType", val, drive + 8);
}
return FALSE;
}
}
break;
case WM_DRIVEIMAGE:
{
HWND ihwnd = WinWindowFromID(hwnd, CBS_IMAGE);
const char *name = (char *)mp1;
int pos;
for (pos = 0; pos < 9; pos++) {
WinDeleteLboxItem(ihwnd, 0);
}
pos = 0;
while (pos < 10 && ui_status.imageHist[pos][0]) {
WinLboxInsertItem(ihwnd, ui_status.imageHist[pos++]);
}
WinLboxInsertItem(ihwnd, "");
if (drive == (int)mp2) {
WinLboxSelectItem(ihwnd, name[0] ? 0 : pos);
}
}
return FALSE;
case WM_TRACK:
if (!(ui_status.lastDriveState & (1 << (int)mp1))) {
break;
}
WinSetDlgSpinVal(hwnd, SPB_TRACK8+(int)mp1, (int)((int)mp2 / 2));
WinShowDlg(hwnd, SS_HALFTRACK8 + (int)mp1, ((int)mp2 % 2));
break;
case WM_DRIVELEDS:
WinShowDlg(hwnd, SS_LED8+(int)mp1, (int)mp2);
break;
case WM_DRIVESTATE:
WinShowDlg(hwnd, SPB_TRACK8, (int)mp1 & 1 == 1);
WinShowDlg(hwnd, SS_HALFTRACK8, (int)mp1 & 1 == 1);
WinShowDlg(hwnd, SPB_TRACK9, (int)mp1 & 2 == 1);
WinShowDlg(hwnd, SS_HALFTRACK9, (int)mp1 & 2 == 1);
WinShowDlg(hwnd, SS_LED8, 0);
WinShowDlg(hwnd, SS_LED9, 0);
break;
case WM_SWITCH:
drive = (int)mp1;
{
const HWND lbox = WinWindowFromID(hwnd, CBS_TYPE);
int type = 0;
int val;
int res;
int drive89 = (drive == 0 || drive == 1);
resources_get_int("DriveTrueEmulation", &val);
WinLboxEmpty(lbox);
if (drive89) {
int i, nr;
WinCheckButton(hwnd, RB_NEVER | get_drive_res("Drive%dExtendImagePolicy", drive), 1);
WinCheckButton(hwnd, RB_NONE | get_drive_res("Drive%dIdleMethod", drive), 1);
nr = 0;
res = get_drive_res("Drive%dType", drive);
for (i = 0; i < nDRIVES; i++) {
if (!drive_check_type(driveRes[i], drive)) {
continue;
}
WinLboxInsertItem(lbox, driveName[i]);
WinLboxSetItemHandle(lbox, nr, driveRes[i]);
if (res == driveRes[i]) {
type = nr;
}
nr++;
}
} else {
WinCheckButton(hwnd, RB_NEVER, 0);
WinCheckButton(hwnd, RB_ASK, 0);
WinCheckButton(hwnd, RB_ALWAYS, 0);
WinCheckButton(hwnd, RB_NONE, 0);
WinCheckButton(hwnd, RB_SKIP, 0);
WinCheckButton(hwnd, RB_TRAP, 0);
}
WinLboxSelectItem(lbox, type);
WinCheckButton(hwnd, CB_PARALLEL, drive89 && get_drive_res("Drive%dParallelCable", drive) != 0);
WinCheckButton(hwnd, CB_MEM2000, drive89 && get_drive_res("Drive%dRAM2000", drive) != 0);
WinCheckButton(hwnd, CB_MEM4000, drive89 && get_drive_res("Drive%dRAM4000", drive) != 0);
WinCheckButton(hwnd, CB_MEM6000, drive89 && get_drive_res("Drive%dRAM6000", drive) != 0);
WinCheckButton(hwnd, CB_MEM8000, drive89 && get_drive_res("Drive%dRAM8000", drive) != 0);
WinCheckButton(hwnd, CB_MEMA000, drive89 && get_drive_res("Drive%dRAMA000", drive) != 0);
WinEnableControl(hwnd, CB_PARALLEL, drive89 && val);
WinEnableControl(hwnd, RB_NEVER, drive89 && val);
WinEnableControl(hwnd, RB_ASK, drive89 && val);
WinEnableControl(hwnd, RB_ALWAYS, drive89 && val);
WinEnableControl(hwnd, RB_NONE, drive89 && val);
WinEnableControl(hwnd, RB_SKIP, drive89 && val);
WinEnableControl(hwnd, RB_TRAP, drive89 && val);
WinEnableControl(hwnd, CBS_TYPE, drive89 && val);
WinEnableControl(hwnd, CB_MEM2000, drive89 && val);
WinEnableControl(hwnd, CB_MEM4000, drive89 && val);
WinEnableControl(hwnd, CB_MEM6000, drive89 && val);
WinEnableControl(hwnd, CB_MEM8000, drive89 && val);
WinEnableControl(hwnd, CB_MEMA000, drive89 && val);
{
int acc = get_drive_res("FileSystemDevice%d", drive) != 0;
int conv = get_drive_res("FSDevice%dConvertP00", drive) != 0;
if (!conv) {
resources_set_int_sprintf("FSDevice%dHideCBMFiles", 0, drive + 8);
}
WinCheckButton(hwnd, CB_ALLOWACCESS, acc);
WinCheckButton(hwnd, CB_CONVERTP00, conv);
WinCheckButton(hwnd, CB_SAVEP00, get_drive_res("FSDevice%dSaveP00", drive) != 0);
WinCheckButton(hwnd, CB_HIDENONP00, get_drive_res("FSDevice%dHideCBMFiles", drive) != 0);
WinEnableControl(hwnd, CB_ALLOWACCESS, !(drive89 && val));
WinEnableControl(hwnd, CB_SAVEP00, !(drive89 && val) && acc);
WinEnableControl(hwnd, CB_CONVERTP00, !(drive89 && val) && acc);
WinEnableControl(hwnd, CBS_PATH, !(drive89 && val) && acc);
WinEnableControl(hwnd, CB_HIDENONP00, !(drive89 && val) && acc && conv);
WinCheckButton(hwnd, CB_READONLY, get_drive_res("AttachDevice%dReadonly", drive) != 0);
}
{
char tmp[CCHMAXPATH];
int max = WinDlgLboxQueryCount(hwnd, CBS_IMAGE);
int pos = -1;
do {
WinLboxQueryItem(hwnd, CBS_IMAGE, ++pos, tmp, CCHMAXPATH);
}
while (pos < max && strcmp(ui_status.lastImage[drive], tmp));
WinDlgLboxSelectItem(hwnd, CBS_IMAGE, pos);
}
{
const char *path;
resources_get_string_sprintf("FSDevice%dDir", &path, drive + 8);
WinSendDlgMsg(hwnd, CBS_PATH, SPBM_SETARRAY, &path, 1);
WinSetDlgSpinVal(hwnd, CBS_PATH, 0);
}
}
return FALSE;
}
return WinDefDlgProc (hwnd, msg, mp1, mp2);
}
static 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);
}
/* Initialize the hardware-level drive emulation (should be called at least
once before anything else). Return 0 on success, -1 on error. */
int drive_init(void)
{
unsigned int dnr;
drive_t *drive;
if (rom_loaded)
return 0;
driverom_init();
drive_image_init();
for (dnr = 0; dnr < DRIVE_NUM; dnr++)
{
char *logname;
drive = drive_context[dnr]->drive;
logname = lib_msprintf("Drive %i", dnr + 8);
lib_free(logname);
drive_clk[dnr] = 0L;
drive->clk = &drive_clk[dnr];
drive->mynumber = dnr;
}
if (driverom_load_images() < 0) {
resources_set_int("Drive8Type", DRIVE_TYPE_NONE);
resources_set_int("Drive9Type", DRIVE_TYPE_NONE);
return -1;
}
#ifdef CELL_DEBUG
printf("INFO: Finished loading ROM images.\n");
#endif
rom_loaded = 1;
drive_overflow_init();
for (dnr = 0; dnr < DRIVE_NUM; dnr++) {
drive = drive_context[dnr]->drive;
drive->drive_ram_expand2 = NULL;
drive->drive_ram_expand4 = NULL;
drive->drive_ram_expand6 = NULL;
drive->drive_ram_expand8 = NULL;
drive->drive_ram_expanda = NULL;
machine_drive_port_default(drive_context[dnr]);
if (drive_check_type(drive->type, dnr) < 1)
resources_set_int_sprintf("Drive%iType", DRIVE_TYPE_NONE, dnr + 8);
machine_drive_rom_setup_image(dnr);
}
for (dnr = 0; dnr < DRIVE_NUM; dnr++) {
drive = drive_context[dnr]->drive;
drive->gcr = gcr_create_image();
drive->byte_ready_level = 1;
drive->byte_ready_edge = 1;
drive->GCR_dirty_track = 0;
drive->GCR_write_value = 0x55;
drive->GCR_track_start_ptr = drive->gcr->data;
drive->GCR_current_track_size = 0;
drive->attach_clk = (CLOCK)0;
drive->detach_clk = (CLOCK)0;
drive->attach_detach_clk = (CLOCK)0;
drive->old_led_status = 0;
drive->old_half_track = 0;
drive->side = 0;
drive->GCR_image_loaded = 0;
drive->read_only = 0;
drive->clock_frequency = 1;
drive->led_last_change_clk = *(drive->clk);
drive->led_last_uiupdate_clk = *(drive->clk);
drive->led_active_ticks = 0;
rotation_reset(drive);
drive_image_init_track_size_d64(drive);
/* Position the R/W head on the directory track. */
drive_set_half_track(36, drive);
drive_led_color[dnr] = DRIVE_ACTIVE_RED;
}
for (dnr = 0; dnr < DRIVE_NUM; dnr++) {
drive = drive_context[dnr]->drive;
driverom_initialize_traps(drive);
drivesync_clock_frequency(drive->type, drive);
rotation_init((drive->clock_frequency == 2) ? 1 : 0, dnr);
drivecpu_init(drive_context[dnr], drive->type);
/* Make sure the sync factor is acknowledged correctly. */
drivesync_factor(drive_context[dnr]);
/* Make sure the traps are moved as needed. */
if (drive->enable)
drive_enable(drive_context[dnr]);
}
return 0;
}
