mirror of
https://github.com/AppleWin/AppleWin.git
synced 2024-09-29 06:55:15 +00:00
Rename Drive_t to FloppyDrive; and prefix members
This commit is contained in:
parent
971eff7875
commit
cd62b82af4
218
source/Disk.cpp
218
source/Disk.cpp
@ -82,26 +82,26 @@ bool DiskIIInterfaceCard::GetEnhanceDisk(void) { return m_enhanceDisk; }
|
|||||||
void DiskIIInterfaceCard::SetEnhanceDisk(bool bEnhanceDisk) { m_enhanceDisk = bEnhanceDisk; }
|
void DiskIIInterfaceCard::SetEnhanceDisk(bool bEnhanceDisk) { m_enhanceDisk = bEnhanceDisk; }
|
||||||
|
|
||||||
int DiskIIInterfaceCard::GetCurrentDrive(void) { return m_currDrive; }
|
int DiskIIInterfaceCard::GetCurrentDrive(void) { return m_currDrive; }
|
||||||
int DiskIIInterfaceCard::GetCurrentTrack(void) { return m_floppyDrive[m_currDrive].track; }
|
int DiskIIInterfaceCard::GetCurrentTrack(void) { return m_floppyDrive[m_currDrive].m_track; }
|
||||||
int DiskIIInterfaceCard::GetCurrentPhase(void) { return m_floppyDrive[m_currDrive].phase; }
|
int DiskIIInterfaceCard::GetCurrentPhase(void) { return m_floppyDrive[m_currDrive].m_phase; }
|
||||||
int DiskIIInterfaceCard::GetCurrentOffset(void) { return m_floppyDrive[m_currDrive].disk.byte; }
|
int DiskIIInterfaceCard::GetCurrentOffset(void) { return m_floppyDrive[m_currDrive].m_disk.byte; }
|
||||||
int DiskIIInterfaceCard::GetTrack(const int drive) { return m_floppyDrive[drive].track; }
|
int DiskIIInterfaceCard::GetTrack(const int drive) { return m_floppyDrive[drive].m_track; }
|
||||||
|
|
||||||
LPCTSTR DiskIIInterfaceCard::GetCurrentState(void)
|
LPCTSTR DiskIIInterfaceCard::GetCurrentState(void)
|
||||||
{
|
{
|
||||||
if (m_floppyDrive[m_currDrive].disk.imagehandle == NULL)
|
if (m_floppyDrive[m_currDrive].m_disk.imagehandle == NULL)
|
||||||
return "Empty";
|
return "Empty";
|
||||||
|
|
||||||
if (!m_floppyMotorOn)
|
if (!m_floppyMotorOn)
|
||||||
{
|
{
|
||||||
if (m_floppyDrive[m_currDrive].spinning > 0)
|
if (m_floppyDrive[m_currDrive].m_spinning > 0)
|
||||||
return "Off (spinning)";
|
return "Off (spinning)";
|
||||||
else
|
else
|
||||||
return "Off";
|
return "Off";
|
||||||
}
|
}
|
||||||
else if (m_floppyWriteMode)
|
else if (m_floppyWriteMode)
|
||||||
{
|
{
|
||||||
if (m_floppyDrive[m_currDrive].disk.bWriteProtected)
|
if (m_floppyDrive[m_currDrive].m_disk.bWriteProtected)
|
||||||
return "Writing (write protected)";
|
return "Writing (write protected)";
|
||||||
else
|
else
|
||||||
return "Writing";
|
return "Writing";
|
||||||
@ -153,7 +153,7 @@ void DiskIIInterfaceCard::SaveLastDiskImage(const int drive)
|
|||||||
if (!m_saveDiskImage)
|
if (!m_saveDiskImage)
|
||||||
return;
|
return;
|
||||||
|
|
||||||
const char *pFileName = m_floppyDrive[drive].disk.fullname;
|
const char *pFileName = m_floppyDrive[drive].m_disk.fullname;
|
||||||
|
|
||||||
if (drive == DRIVE_1)
|
if (drive == DRIVE_1)
|
||||||
RegSaveString(TEXT(REG_PREFS), REGVALUE_PREF_LAST_DISK_1, TRUE, pFileName);
|
RegSaveString(TEXT(REG_PREFS), REGVALUE_PREF_LAST_DISK_1, TRUE, pFileName);
|
||||||
@ -177,10 +177,10 @@ void DiskIIInterfaceCard::SaveLastDiskImage(const int drive)
|
|||||||
// Called by DiskControlMotor() & DiskEnable()
|
// Called by DiskControlMotor() & DiskEnable()
|
||||||
void DiskIIInterfaceCard::CheckSpinning(const ULONG nExecutedCycles)
|
void DiskIIInterfaceCard::CheckSpinning(const ULONG nExecutedCycles)
|
||||||
{
|
{
|
||||||
DWORD modechange = (m_floppyMotorOn && !m_floppyDrive[m_currDrive].spinning);
|
DWORD modechange = (m_floppyMotorOn && !m_floppyDrive[m_currDrive].m_spinning);
|
||||||
|
|
||||||
if (m_floppyMotorOn)
|
if (m_floppyMotorOn)
|
||||||
m_floppyDrive[m_currDrive].spinning = SPINNING_CYCLES;
|
m_floppyDrive[m_currDrive].m_spinning = SPINNING_CYCLES;
|
||||||
|
|
||||||
if (modechange)
|
if (modechange)
|
||||||
FrameDrawDiskLEDS( (HDC)0 );
|
FrameDrawDiskLEDS( (HDC)0 );
|
||||||
@ -199,14 +199,14 @@ Disk_Status_e DiskIIInterfaceCard::GetDriveLightStatus(const int drive)
|
|||||||
{
|
{
|
||||||
if (IsDriveValid( drive ))
|
if (IsDriveValid( drive ))
|
||||||
{
|
{
|
||||||
Drive_t* pDrive = &m_floppyDrive[ drive ];
|
FloppyDrive* pDrive = &m_floppyDrive[ drive ];
|
||||||
|
|
||||||
if (pDrive->spinning)
|
if (pDrive->m_spinning)
|
||||||
{
|
{
|
||||||
if (pDrive->disk.bWriteProtected)
|
if (pDrive->m_disk.bWriteProtected)
|
||||||
return DISK_STATUS_PROT;
|
return DISK_STATUS_PROT;
|
||||||
|
|
||||||
if (pDrive->writelight)
|
if (pDrive->m_writelight)
|
||||||
return DISK_STATUS_WRITE;
|
return DISK_STATUS_WRITE;
|
||||||
else
|
else
|
||||||
return DISK_STATUS_READ;
|
return DISK_STATUS_READ;
|
||||||
@ -231,7 +231,7 @@ bool DiskIIInterfaceCard::IsDriveValid(const int drive)
|
|||||||
|
|
||||||
void DiskIIInterfaceCard::AllocTrack(const int drive)
|
void DiskIIInterfaceCard::AllocTrack(const int drive)
|
||||||
{
|
{
|
||||||
Disk_t* pFloppy = &m_floppyDrive[drive].disk;
|
Disk_t* pFloppy = &m_floppyDrive[drive].m_disk;
|
||||||
pFloppy->trackimage = (LPBYTE)VirtualAlloc(NULL, NIBBLES_PER_TRACK, MEM_COMMIT, PAGE_READWRITE);
|
pFloppy->trackimage = (LPBYTE)VirtualAlloc(NULL, NIBBLES_PER_TRACK, MEM_COMMIT, PAGE_READWRITE);
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -242,10 +242,10 @@ void DiskIIInterfaceCard::ReadTrack(const int drive)
|
|||||||
if (! IsDriveValid( drive ))
|
if (! IsDriveValid( drive ))
|
||||||
return;
|
return;
|
||||||
|
|
||||||
Drive_t* pDrive = &m_floppyDrive[ drive ];
|
FloppyDrive* pDrive = &m_floppyDrive[ drive ];
|
||||||
Disk_t* pFloppy = &pDrive->disk;
|
Disk_t* pFloppy = &pDrive->m_disk;
|
||||||
|
|
||||||
if (pDrive->track >= ImageGetNumTracks(pFloppy->imagehandle))
|
if (pDrive->m_track >= ImageGetNumTracks(pFloppy->imagehandle))
|
||||||
{
|
{
|
||||||
pFloppy->trackimagedata = false;
|
pFloppy->trackimagedata = false;
|
||||||
return;
|
return;
|
||||||
@ -261,8 +261,8 @@ void DiskIIInterfaceCard::ReadTrack(const int drive)
|
|||||||
#endif
|
#endif
|
||||||
ImageReadTrack(
|
ImageReadTrack(
|
||||||
pFloppy->imagehandle,
|
pFloppy->imagehandle,
|
||||||
pDrive->track,
|
pDrive->m_track,
|
||||||
pDrive->phase,
|
pDrive->m_phase,
|
||||||
pFloppy->trackimage,
|
pFloppy->trackimage,
|
||||||
&pFloppy->nibbles,
|
&pFloppy->nibbles,
|
||||||
m_enhanceDisk);
|
m_enhanceDisk);
|
||||||
@ -276,7 +276,7 @@ void DiskIIInterfaceCard::ReadTrack(const int drive)
|
|||||||
|
|
||||||
void DiskIIInterfaceCard::RemoveDisk(const int drive)
|
void DiskIIInterfaceCard::RemoveDisk(const int drive)
|
||||||
{
|
{
|
||||||
Disk_t* pFloppy = &m_floppyDrive[drive].disk;
|
Disk_t* pFloppy = &m_floppyDrive[drive].m_disk;
|
||||||
|
|
||||||
if (pFloppy->imagehandle)
|
if (pFloppy->imagehandle)
|
||||||
{
|
{
|
||||||
@ -305,10 +305,10 @@ void DiskIIInterfaceCard::RemoveDisk(const int drive)
|
|||||||
|
|
||||||
void DiskIIInterfaceCard::WriteTrack(const int drive)
|
void DiskIIInterfaceCard::WriteTrack(const int drive)
|
||||||
{
|
{
|
||||||
Drive_t* pDrive = &m_floppyDrive[ drive ];
|
FloppyDrive* pDrive = &m_floppyDrive[ drive ];
|
||||||
Disk_t* pFloppy = &pDrive->disk;
|
Disk_t* pFloppy = &pDrive->m_disk;
|
||||||
|
|
||||||
if (pDrive->track >= ImageGetNumTracks(pFloppy->imagehandle))
|
if (pDrive->m_track >= ImageGetNumTracks(pFloppy->imagehandle))
|
||||||
return;
|
return;
|
||||||
|
|
||||||
if (pFloppy->bWriteProtected)
|
if (pFloppy->bWriteProtected)
|
||||||
@ -321,8 +321,8 @@ void DiskIIInterfaceCard::WriteTrack(const int drive)
|
|||||||
#endif
|
#endif
|
||||||
ImageWriteTrack(
|
ImageWriteTrack(
|
||||||
pFloppy->imagehandle,
|
pFloppy->imagehandle,
|
||||||
pDrive->track,
|
pDrive->m_track,
|
||||||
pDrive->phase, // TODO: this should never be used; it's the current phase (half-track), not that of the track to be written (nickw)
|
pDrive->m_phase, // TODO: this should never be used; it's the current phase (half-track), not that of the track to be written (nickw)
|
||||||
pFloppy->trackimage,
|
pFloppy->trackimage,
|
||||||
pFloppy->nibbles);
|
pFloppy->nibbles);
|
||||||
}
|
}
|
||||||
@ -332,7 +332,7 @@ void DiskIIInterfaceCard::WriteTrack(const int drive)
|
|||||||
|
|
||||||
void DiskIIInterfaceCard::FlushCurrentTrack(const int drive)
|
void DiskIIInterfaceCard::FlushCurrentTrack(const int drive)
|
||||||
{
|
{
|
||||||
Disk_t* pFloppy = &m_floppyDrive[drive].disk;
|
Disk_t* pFloppy = &m_floppyDrive[drive].m_disk;
|
||||||
|
|
||||||
if (pFloppy->trackimage && pFloppy->trackimagedirty)
|
if (pFloppy->trackimage && pFloppy->trackimagedirty)
|
||||||
WriteTrack(drive);
|
WriteTrack(drive);
|
||||||
@ -344,7 +344,7 @@ void DiskIIInterfaceCard::Boot(void)
|
|||||||
{
|
{
|
||||||
// THIS FUNCTION RELOADS A PROGRAM IMAGE IF ONE IS LOADED IN DRIVE ONE.
|
// THIS FUNCTION RELOADS A PROGRAM IMAGE IF ONE IS LOADED IN DRIVE ONE.
|
||||||
// IF A DISK IMAGE OR NO IMAGE IS LOADED IN DRIVE ONE, IT DOES NOTHING.
|
// IF A DISK IMAGE OR NO IMAGE IS LOADED IN DRIVE ONE, IT DOES NOTHING.
|
||||||
if (m_floppyDrive[0].disk.imagehandle && ImageBoot(m_floppyDrive[0].disk.imagehandle))
|
if (m_floppyDrive[0].m_disk.imagehandle && ImageBoot(m_floppyDrive[0].m_disk.imagehandle))
|
||||||
m_floppyMotorOn = 0;
|
m_floppyMotorOn = 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -370,12 +370,12 @@ void __stdcall DiskIIInterfaceCard::ControlMotor(WORD, WORD address, BYTE, BYTE,
|
|||||||
|
|
||||||
void __stdcall DiskIIInterfaceCard::ControlStepper(WORD, WORD address, BYTE, BYTE, ULONG uExecutedCycles)
|
void __stdcall DiskIIInterfaceCard::ControlStepper(WORD, WORD address, BYTE, BYTE, ULONG uExecutedCycles)
|
||||||
{
|
{
|
||||||
Drive_t* pDrive = &m_floppyDrive[m_currDrive];
|
FloppyDrive* pDrive = &m_floppyDrive[m_currDrive];
|
||||||
Disk_t* pFloppy = &pDrive->disk;
|
Disk_t* pFloppy = &pDrive->m_disk;
|
||||||
|
|
||||||
if (!m_floppyMotorOn) // GH#525
|
if (!m_floppyMotorOn) // GH#525
|
||||||
{
|
{
|
||||||
if (!pDrive->spinning)
|
if (!pDrive->m_spinning)
|
||||||
{
|
{
|
||||||
#if LOG_DISK_PHASES
|
#if LOG_DISK_PHASES
|
||||||
LOG_DISK("stepper accessed whilst motor is off and not spinning\r\n");
|
LOG_DISK("stepper accessed whilst motor is off and not spinning\r\n");
|
||||||
@ -410,22 +410,22 @@ void __stdcall DiskIIInterfaceCard::ControlStepper(WORD, WORD address, BYTE, BYT
|
|||||||
// - do not move if both adjacent magnets are on
|
// - do not move if both adjacent magnets are on
|
||||||
// momentum and timing are not accounted for ... maybe one day!
|
// momentum and timing are not accounted for ... maybe one day!
|
||||||
int direction = 0;
|
int direction = 0;
|
||||||
if (m_phases & (1 << ((pDrive->phase + 1) & 3)))
|
if (m_phases & (1 << ((pDrive->m_phase + 1) & 3)))
|
||||||
direction += 1;
|
direction += 1;
|
||||||
if (m_phases & (1 << ((pDrive->phase + 3) & 3)))
|
if (m_phases & (1 << ((pDrive->m_phase + 3) & 3)))
|
||||||
direction -= 1;
|
direction -= 1;
|
||||||
|
|
||||||
// apply magnet step, if any
|
// apply magnet step, if any
|
||||||
if (direction)
|
if (direction)
|
||||||
{
|
{
|
||||||
pDrive->phase = MAX(0, MIN(79, pDrive->phase + direction));
|
pDrive->m_phase = MAX(0, MIN(79, pDrive->m_phase + direction));
|
||||||
const int nNumTracksInImage = ImageGetNumTracks(pFloppy->imagehandle);
|
const int nNumTracksInImage = ImageGetNumTracks(pFloppy->imagehandle);
|
||||||
const int newtrack = (nNumTracksInImage == 0) ? 0
|
const int newtrack = (nNumTracksInImage == 0) ? 0
|
||||||
: MIN(nNumTracksInImage-1, pDrive->phase >> 1); // (round half tracks down)
|
: MIN(nNumTracksInImage-1, pDrive->m_phase >> 1); // (round half tracks down)
|
||||||
if (newtrack != pDrive->track)
|
if (newtrack != pDrive->m_track)
|
||||||
{
|
{
|
||||||
FlushCurrentTrack(m_currDrive);
|
FlushCurrentTrack(m_currDrive);
|
||||||
pDrive->track = newtrack;
|
pDrive->m_track = newtrack;
|
||||||
pFloppy->trackimagedata = false;
|
pFloppy->trackimagedata = false;
|
||||||
|
|
||||||
m_formatTrack.DriveNotWritingTrack();
|
m_formatTrack.DriveNotWritingTrack();
|
||||||
@ -474,8 +474,8 @@ void __stdcall DiskIIInterfaceCard::Enable(WORD, WORD address, BYTE, BYTE, ULONG
|
|||||||
#if LOG_DISK_ENABLE_DRIVE
|
#if LOG_DISK_ENABLE_DRIVE
|
||||||
LOG_DISK("enable drive: %d\r\n", m_currDrive);
|
LOG_DISK("enable drive: %d\r\n", m_currDrive);
|
||||||
#endif
|
#endif
|
||||||
m_floppyDrive[!m_currDrive].spinning = 0;
|
m_floppyDrive[!m_currDrive].m_spinning = 0;
|
||||||
m_floppyDrive[!m_currDrive].writelight = 0;
|
m_floppyDrive[!m_currDrive].m_writelight = 0;
|
||||||
CheckSpinning(uExecutedCycles);
|
CheckSpinning(uExecutedCycles);
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -495,8 +495,8 @@ void DiskIIInterfaceCard::EjectDisk(const int drive)
|
|||||||
// . Used by Drive Buttons' tooltips
|
// . Used by Drive Buttons' tooltips
|
||||||
LPCTSTR DiskIIInterfaceCard::GetFullDiskFilename(const int drive)
|
LPCTSTR DiskIIInterfaceCard::GetFullDiskFilename(const int drive)
|
||||||
{
|
{
|
||||||
if (!m_floppyDrive[drive].disk.strFilenameInZip.empty())
|
if (!m_floppyDrive[drive].m_disk.strFilenameInZip.empty())
|
||||||
return m_floppyDrive[drive].disk.strFilenameInZip.c_str();
|
return m_floppyDrive[drive].m_disk.strFilenameInZip.c_str();
|
||||||
|
|
||||||
return GetFullName(drive);
|
return GetFullName(drive);
|
||||||
}
|
}
|
||||||
@ -505,19 +505,19 @@ LPCTSTR DiskIIInterfaceCard::GetFullDiskFilename(const int drive)
|
|||||||
// . Used by Property Sheet Page (Disk)
|
// . Used by Property Sheet Page (Disk)
|
||||||
LPCTSTR DiskIIInterfaceCard::GetFullName(const int drive)
|
LPCTSTR DiskIIInterfaceCard::GetFullName(const int drive)
|
||||||
{
|
{
|
||||||
return m_floppyDrive[drive].disk.fullname;
|
return m_floppyDrive[drive].m_disk.fullname;
|
||||||
}
|
}
|
||||||
|
|
||||||
// Return the imagename
|
// Return the imagename
|
||||||
// . Used by Drive Button's icons & Property Sheet Page (Save snapshot)
|
// . Used by Drive Button's icons & Property Sheet Page (Save snapshot)
|
||||||
LPCTSTR DiskIIInterfaceCard::GetBaseName(const int drive)
|
LPCTSTR DiskIIInterfaceCard::GetBaseName(const int drive)
|
||||||
{
|
{
|
||||||
return m_floppyDrive[drive].disk.imagename;
|
return m_floppyDrive[drive].m_disk.imagename;
|
||||||
}
|
}
|
||||||
|
|
||||||
LPCTSTR DiskIIInterfaceCard::DiskGetFullPathName(const int drive)
|
LPCTSTR DiskIIInterfaceCard::DiskGetFullPathName(const int drive)
|
||||||
{
|
{
|
||||||
return ImageGetPathname(m_floppyDrive[drive].disk.imagehandle);
|
return ImageGetPathname(m_floppyDrive[drive].m_disk.imagehandle);
|
||||||
}
|
}
|
||||||
|
|
||||||
//===========================================================================
|
//===========================================================================
|
||||||
@ -535,8 +535,8 @@ void DiskIIInterfaceCard::GetLightStatus(Disk_Status_e *pDisk1Status, Disk_Statu
|
|||||||
|
|
||||||
ImageError_e DiskIIInterfaceCard::InsertDisk(const int drive, LPCTSTR pszImageFilename, const bool bForceWriteProtected, const bool bCreateIfNecessary)
|
ImageError_e DiskIIInterfaceCard::InsertDisk(const int drive, LPCTSTR pszImageFilename, const bool bForceWriteProtected, const bool bCreateIfNecessary)
|
||||||
{
|
{
|
||||||
Drive_t* pDrive = &m_floppyDrive[drive];
|
FloppyDrive* pDrive = &m_floppyDrive[drive];
|
||||||
Disk_t* pFloppy = &pDrive->disk;
|
Disk_t* pFloppy = &pDrive->m_disk;
|
||||||
|
|
||||||
if (pFloppy->imagehandle)
|
if (pFloppy->imagehandle)
|
||||||
RemoveDisk(drive);
|
RemoveDisk(drive);
|
||||||
@ -544,11 +544,11 @@ ImageError_e DiskIIInterfaceCard::InsertDisk(const int drive, LPCTSTR pszImageFi
|
|||||||
// Reset the drive's struct, but preserve the physical attributes (bug#18242: Platoon)
|
// Reset the drive's struct, but preserve the physical attributes (bug#18242: Platoon)
|
||||||
// . Changing the disk (in the drive) doesn't affect the drive's head etc.
|
// . Changing the disk (in the drive) doesn't affect the drive's head etc.
|
||||||
{
|
{
|
||||||
int track = pDrive->track;
|
int track = pDrive->m_track;
|
||||||
int phase = pDrive->phase;
|
int phase = pDrive->m_phase;
|
||||||
pDrive->clear();
|
pDrive->clear();
|
||||||
pDrive->track = track;
|
pDrive->m_track = track;
|
||||||
pDrive->phase = phase;
|
pDrive->m_phase = phase;
|
||||||
}
|
}
|
||||||
|
|
||||||
const DWORD dwAttributes = GetFileAttributes(pszImageFilename);
|
const DWORD dwAttributes = GetFileAttributes(pszImageFilename);
|
||||||
@ -683,7 +683,7 @@ void DiskIIInterfaceCard::NotifyInvalidImage(const int drive, LPCTSTR pszImageFi
|
|||||||
TEXT("first file (%s) in this multi-zip archive is not recognized.\n")
|
TEXT("first file (%s) in this multi-zip archive is not recognized.\n")
|
||||||
TEXT("Try unzipping and using the disk images directly.\n"),
|
TEXT("Try unzipping and using the disk images directly.\n"),
|
||||||
pszImageFilename,
|
pszImageFilename,
|
||||||
m_floppyDrive[drive].disk.strFilenameInZip.c_str());
|
m_floppyDrive[drive].m_disk.strFilenameInZip.c_str());
|
||||||
break;
|
break;
|
||||||
|
|
||||||
case eIMAGE_ERROR_GZ:
|
case eIMAGE_ERROR_GZ:
|
||||||
@ -738,7 +738,7 @@ bool DiskIIInterfaceCard::GetProtect(const int drive)
|
|||||||
{
|
{
|
||||||
if (IsDriveValid(drive))
|
if (IsDriveValid(drive))
|
||||||
{
|
{
|
||||||
if (m_floppyDrive[drive].disk.bWriteProtected)
|
if (m_floppyDrive[drive].m_disk.bWriteProtected)
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -751,7 +751,7 @@ void DiskIIInterfaceCard::SetProtect(const int drive, const bool bWriteProtect)
|
|||||||
{
|
{
|
||||||
if (IsDriveValid( drive ))
|
if (IsDriveValid( drive ))
|
||||||
{
|
{
|
||||||
m_floppyDrive[drive].disk.bWriteProtected = bWriteProtect;
|
m_floppyDrive[drive].m_disk.bWriteProtected = bWriteProtect;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -762,7 +762,7 @@ bool DiskIIInterfaceCard::IsDiskImageWriteProtected(const int drive)
|
|||||||
if (!IsDriveValid(drive))
|
if (!IsDriveValid(drive))
|
||||||
return true;
|
return true;
|
||||||
|
|
||||||
return ImageIsWriteProtected(m_floppyDrive[drive].disk.imagehandle);
|
return ImageIsWriteProtected(m_floppyDrive[drive].m_disk.imagehandle);
|
||||||
}
|
}
|
||||||
|
|
||||||
//===========================================================================
|
//===========================================================================
|
||||||
@ -772,7 +772,7 @@ bool DiskIIInterfaceCard::IsDriveEmpty(const int drive)
|
|||||||
if (!IsDriveValid(drive))
|
if (!IsDriveValid(drive))
|
||||||
return true;
|
return true;
|
||||||
|
|
||||||
return m_floppyDrive[drive].disk.imagehandle == NULL;
|
return m_floppyDrive[drive].m_disk.imagehandle == NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
//===========================================================================
|
//===========================================================================
|
||||||
@ -811,8 +811,8 @@ bool DiskIIInterfaceCard::LogWriteCheckSyncFF(ULONG& uCycleDelta)
|
|||||||
void __stdcall DiskIIInterfaceCard::ReadWrite(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
|
void __stdcall DiskIIInterfaceCard::ReadWrite(WORD pc, WORD addr, BYTE bWrite, BYTE d, ULONG nExecutedCycles)
|
||||||
{
|
{
|
||||||
/* m_floppyLoadMode = 0; */
|
/* m_floppyLoadMode = 0; */
|
||||||
Drive_t* pDrive = &m_floppyDrive[m_currDrive];
|
FloppyDrive* pDrive = &m_floppyDrive[m_currDrive];
|
||||||
Disk_t* pFloppy = &pDrive->disk;
|
Disk_t* pFloppy = &pDrive->m_disk;
|
||||||
|
|
||||||
if (!pFloppy->trackimagedata && pFloppy->imagehandle)
|
if (!pFloppy->trackimagedata && pFloppy->imagehandle)
|
||||||
ReadTrack(m_currDrive);
|
ReadTrack(m_currDrive);
|
||||||
@ -827,7 +827,7 @@ void __stdcall DiskIIInterfaceCard::ReadWrite(WORD pc, WORD addr, BYTE bWrite, B
|
|||||||
UINT uSpinNibbleCount = 0;
|
UINT uSpinNibbleCount = 0;
|
||||||
CpuCalcCycles(nExecutedCycles); // g_nCumulativeCycles required for uSpinNibbleCount & LogWriteCheckSyncFF()
|
CpuCalcCycles(nExecutedCycles); // g_nCumulativeCycles required for uSpinNibbleCount & LogWriteCheckSyncFF()
|
||||||
|
|
||||||
if (!m_enhanceDisk && pDrive->spinning)
|
if (!m_enhanceDisk && pDrive->m_spinning)
|
||||||
{
|
{
|
||||||
const ULONG nCycleDiff = (ULONG) (g_nCumulativeCycles - m_diskLastCycle);
|
const ULONG nCycleDiff = (ULONG) (g_nCumulativeCycles - m_diskLastCycle);
|
||||||
m_diskLastCycle = g_nCumulativeCycles;
|
m_diskLastCycle = g_nCumulativeCycles;
|
||||||
@ -854,7 +854,7 @@ void __stdcall DiskIIInterfaceCard::ReadWrite(WORD pc, WORD addr, BYTE bWrite, B
|
|||||||
// Don't change latch if drive off after 1 second drive-off delay (UTAIIe page 9-13)
|
// Don't change latch if drive off after 1 second drive-off delay (UTAIIe page 9-13)
|
||||||
// "DRIVES OFF forces the data register to hold its present state." (UTAIIe page 9-12)
|
// "DRIVES OFF forces the data register to hold its present state." (UTAIIe page 9-12)
|
||||||
// Note: Sherwood Forest sets shift mode and reads with the drive off.
|
// Note: Sherwood Forest sets shift mode and reads with the drive off.
|
||||||
if (!pDrive->spinning) // GH#599
|
if (!pDrive->m_spinning) // GH#599
|
||||||
return;
|
return;
|
||||||
|
|
||||||
const ULONG nReadCycleDiff = (ULONG) (g_nCumulativeCycles - m_diskLastReadLatchCycle);
|
const ULONG nReadCycleDiff = (ULONG) (g_nCumulativeCycles - m_diskLastReadLatchCycle);
|
||||||
@ -939,10 +939,10 @@ void DiskIIInterfaceCard::Reset(const bool bIsPowerCycle/*=false*/)
|
|||||||
// . The initial machine start-up state is track=0, but after a power-cycle the track could be any value.
|
// . The initial machine start-up state is track=0, but after a power-cycle the track could be any value.
|
||||||
// . (For DiskII firmware, this results in a subtle extra latch read in this latter case, for the track!=0 case)
|
// . (For DiskII firmware, this results in a subtle extra latch read in this latter case, for the track!=0 case)
|
||||||
|
|
||||||
m_floppyDrive[DRIVE_1].spinning = 0;
|
m_floppyDrive[DRIVE_1].m_spinning = 0;
|
||||||
m_floppyDrive[DRIVE_1].writelight = 0;
|
m_floppyDrive[DRIVE_1].m_writelight = 0;
|
||||||
m_floppyDrive[DRIVE_2].spinning = 0;
|
m_floppyDrive[DRIVE_2].m_spinning = 0;
|
||||||
m_floppyDrive[DRIVE_2].writelight = 0;
|
m_floppyDrive[DRIVE_2].m_writelight = 0;
|
||||||
|
|
||||||
FrameRefreshStatus(DRAW_LEDS, false);
|
FrameRefreshStatus(DRAW_LEDS, false);
|
||||||
}
|
}
|
||||||
@ -1008,7 +1008,7 @@ void __stdcall DiskIIInterfaceCard::LoadWriteProtect(WORD, WORD, BYTE write, BYT
|
|||||||
// Don't change latch if drive off after 1 second drive-off delay (UTAIIe page 9-13)
|
// Don't change latch if drive off after 1 second drive-off delay (UTAIIe page 9-13)
|
||||||
// "DRIVES OFF forces the data register to hold its present state." (UTAIIe page 9-12)
|
// "DRIVES OFF forces the data register to hold its present state." (UTAIIe page 9-12)
|
||||||
// Note: Gemstone Warrior sets load mode with the drive off.
|
// Note: Gemstone Warrior sets load mode with the drive off.
|
||||||
if (!m_floppyDrive[m_currDrive].spinning) // GH#599
|
if (!m_floppyDrive[m_currDrive].m_spinning) // GH#599
|
||||||
return;
|
return;
|
||||||
|
|
||||||
if (!write)
|
if (!write)
|
||||||
@ -1018,7 +1018,7 @@ void __stdcall DiskIIInterfaceCard::LoadWriteProtect(WORD, WORD, BYTE write, BYT
|
|||||||
// . write mode doesn't prevent reading write protect (GH#537):
|
// . write mode doesn't prevent reading write protect (GH#537):
|
||||||
// "If for some reason the above write protect check were entered with the READ/WRITE switch in WRITE,
|
// "If for some reason the above write protect check were entered with the READ/WRITE switch in WRITE,
|
||||||
// the write protect switch would still be read correctly" (UTAIIe page 9-21)
|
// the write protect switch would still be read correctly" (UTAIIe page 9-21)
|
||||||
if (m_floppyDrive[m_currDrive].disk.bWriteProtected)
|
if (m_floppyDrive[m_currDrive].m_disk.bWriteProtected)
|
||||||
m_floppyLatch |= 0x80;
|
m_floppyLatch |= 0x80;
|
||||||
else
|
else
|
||||||
m_floppyLatch &= 0x7F;
|
m_floppyLatch &= 0x7F;
|
||||||
@ -1031,7 +1031,7 @@ void __stdcall DiskIIInterfaceCard::SetReadMode(WORD, WORD, BYTE, BYTE, ULONG)
|
|||||||
{
|
{
|
||||||
m_floppyWriteMode = 0;
|
m_floppyWriteMode = 0;
|
||||||
|
|
||||||
m_formatTrack.DriveSwitchedToReadMode(&m_floppyDrive[m_currDrive].disk);
|
m_formatTrack.DriveSwitchedToReadMode(&m_floppyDrive[m_currDrive].m_disk);
|
||||||
|
|
||||||
#if LOG_DISK_RW_MODE
|
#if LOG_DISK_RW_MODE
|
||||||
LOG_DISK("rw mode: read\r\n");
|
LOG_DISK("rw mode: read\r\n");
|
||||||
@ -1044,9 +1044,9 @@ void __stdcall DiskIIInterfaceCard::SetWriteMode(WORD, WORD, BYTE, BYTE, ULONG u
|
|||||||
{
|
{
|
||||||
m_floppyWriteMode = 1;
|
m_floppyWriteMode = 1;
|
||||||
|
|
||||||
m_formatTrack.DriveSwitchedToWriteMode(m_floppyDrive[m_currDrive].disk.byte);
|
m_formatTrack.DriveSwitchedToWriteMode(m_floppyDrive[m_currDrive].m_disk.byte);
|
||||||
|
|
||||||
BOOL modechange = !m_floppyDrive[m_currDrive].writelight;
|
BOOL modechange = !m_floppyDrive[m_currDrive].m_writelight;
|
||||||
#if LOG_DISK_RW_MODE
|
#if LOG_DISK_RW_MODE
|
||||||
LOG_DISK("rw mode: write (mode changed=%d)\r\n", modechange ? 1 : 0);
|
LOG_DISK("rw mode: write (mode changed=%d)\r\n", modechange ? 1 : 0);
|
||||||
#endif
|
#endif
|
||||||
@ -1054,7 +1054,7 @@ void __stdcall DiskIIInterfaceCard::SetWriteMode(WORD, WORD, BYTE, BYTE, ULONG u
|
|||||||
m_uWriteLastCycle = 0;
|
m_uWriteLastCycle = 0;
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
m_floppyDrive[m_currDrive].writelight = WRITELIGHT_CYCLES;
|
m_floppyDrive[m_currDrive].m_writelight = WRITELIGHT_CYCLES;
|
||||||
|
|
||||||
if (modechange)
|
if (modechange)
|
||||||
FrameDrawDiskLEDS( (HDC)0 );
|
FrameDrawDiskLEDS( (HDC)0 );
|
||||||
@ -1067,24 +1067,24 @@ void DiskIIInterfaceCard::UpdateDriveState(DWORD cycles)
|
|||||||
int loop = NUM_DRIVES;
|
int loop = NUM_DRIVES;
|
||||||
while (loop--)
|
while (loop--)
|
||||||
{
|
{
|
||||||
Drive_t* pDrive = &m_floppyDrive[loop];
|
FloppyDrive* pDrive = &m_floppyDrive[loop];
|
||||||
|
|
||||||
if (pDrive->spinning && !m_floppyMotorOn)
|
if (pDrive->m_spinning && !m_floppyMotorOn)
|
||||||
{
|
{
|
||||||
if (!(pDrive->spinning -= MIN(pDrive->spinning, cycles)))
|
if (!(pDrive->m_spinning -= MIN(pDrive->m_spinning, cycles)))
|
||||||
{
|
{
|
||||||
FrameDrawDiskLEDS( (HDC)0 );
|
FrameDrawDiskLEDS( (HDC)0 );
|
||||||
FrameDrawDiskStatus( (HDC)0 );
|
FrameDrawDiskStatus( (HDC)0 );
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if (m_floppyWriteMode && (m_currDrive == loop) && pDrive->spinning)
|
if (m_floppyWriteMode && (m_currDrive == loop) && pDrive->m_spinning)
|
||||||
{
|
{
|
||||||
pDrive->writelight = WRITELIGHT_CYCLES;
|
pDrive->m_writelight = WRITELIGHT_CYCLES;
|
||||||
}
|
}
|
||||||
else if (pDrive->writelight)
|
else if (pDrive->m_writelight)
|
||||||
{
|
{
|
||||||
if (!(pDrive->writelight -= MIN(pDrive->writelight, cycles)))
|
if (!(pDrive->m_writelight -= MIN(pDrive->m_writelight, cycles)))
|
||||||
{
|
{
|
||||||
FrameDrawDiskLEDS( (HDC)0 );
|
FrameDrawDiskLEDS( (HDC)0 );
|
||||||
FrameDrawDiskStatus( (HDC)0 );
|
FrameDrawDiskStatus( (HDC)0 );
|
||||||
@ -1099,7 +1099,7 @@ bool DiskIIInterfaceCard::DriveSwap(void)
|
|||||||
{
|
{
|
||||||
// Refuse to swap if either Disk][ is active
|
// Refuse to swap if either Disk][ is active
|
||||||
// TODO: if Shift-Click then FORCE drive swap to bypass message
|
// TODO: if Shift-Click then FORCE drive swap to bypass message
|
||||||
if (m_floppyDrive[DRIVE_1].spinning || m_floppyDrive[DRIVE_2].spinning)
|
if (m_floppyDrive[DRIVE_1].m_spinning || m_floppyDrive[DRIVE_2].m_spinning)
|
||||||
{
|
{
|
||||||
// 1.26.2.4 Prompt when trying to swap disks while drive is on instead of silently failing
|
// 1.26.2.4 Prompt when trying to swap disks while drive is on instead of silently failing
|
||||||
int status = MessageBox(
|
int status = MessageBox(
|
||||||
@ -1134,11 +1134,11 @@ bool DiskIIInterfaceCard::DriveSwap(void)
|
|||||||
|
|
||||||
// Swap disks between drives
|
// Swap disks between drives
|
||||||
// . NB. We swap trackimage ptrs (so don't need to swap the buffers' data)
|
// . NB. We swap trackimage ptrs (so don't need to swap the buffers' data)
|
||||||
std::swap(m_floppyDrive[DRIVE_1].disk, m_floppyDrive[DRIVE_2].disk);
|
std::swap(m_floppyDrive[DRIVE_1].m_disk, m_floppyDrive[DRIVE_2].m_disk);
|
||||||
|
|
||||||
// Invalidate the trackimage so that a read latch will re-read the track for the new floppy (GH#543)
|
// Invalidate the trackimage so that a read latch will re-read the track for the new floppy (GH#543)
|
||||||
m_floppyDrive[DRIVE_1].disk.trackimagedata = false;
|
m_floppyDrive[DRIVE_1].m_disk.trackimagedata = false;
|
||||||
m_floppyDrive[DRIVE_2].disk.trackimagedata = false;
|
m_floppyDrive[DRIVE_2].m_disk.trackimagedata = false;
|
||||||
|
|
||||||
SaveLastDiskImage(DRIVE_1);
|
SaveLastDiskImage(DRIVE_1);
|
||||||
SaveLastDiskImage(DRIVE_2);
|
SaveLastDiskImage(DRIVE_2);
|
||||||
@ -1293,21 +1293,21 @@ std::string DiskIIInterfaceCard::GetSnapshotCardName(void)
|
|||||||
void DiskIIInterfaceCard::SaveSnapshotDisk2Unit(YamlSaveHelper& yamlSaveHelper, UINT unit)
|
void DiskIIInterfaceCard::SaveSnapshotDisk2Unit(YamlSaveHelper& yamlSaveHelper, UINT unit)
|
||||||
{
|
{
|
||||||
YamlSaveHelper::Label label(yamlSaveHelper, "%s%d:\n", SS_YAML_KEY_DISK2UNIT, unit);
|
YamlSaveHelper::Label label(yamlSaveHelper, "%s%d:\n", SS_YAML_KEY_DISK2UNIT, unit);
|
||||||
yamlSaveHelper.SaveString(SS_YAML_KEY_FILENAME, m_floppyDrive[unit].disk.fullname);
|
yamlSaveHelper.SaveString(SS_YAML_KEY_FILENAME, m_floppyDrive[unit].m_disk.fullname);
|
||||||
yamlSaveHelper.SaveUint(SS_YAML_KEY_TRACK, m_floppyDrive[unit].track);
|
yamlSaveHelper.SaveUint(SS_YAML_KEY_TRACK, m_floppyDrive[unit].m_track);
|
||||||
yamlSaveHelper.SaveUint(SS_YAML_KEY_PHASE, m_floppyDrive[unit].phase);
|
yamlSaveHelper.SaveUint(SS_YAML_KEY_PHASE, m_floppyDrive[unit].m_phase);
|
||||||
yamlSaveHelper.SaveHexUint16(SS_YAML_KEY_BYTE, m_floppyDrive[unit].disk.byte);
|
yamlSaveHelper.SaveHexUint16(SS_YAML_KEY_BYTE, m_floppyDrive[unit].m_disk.byte);
|
||||||
yamlSaveHelper.SaveBool(SS_YAML_KEY_WRITE_PROTECTED, m_floppyDrive[unit].disk.bWriteProtected);
|
yamlSaveHelper.SaveBool(SS_YAML_KEY_WRITE_PROTECTED, m_floppyDrive[unit].m_disk.bWriteProtected);
|
||||||
yamlSaveHelper.SaveUint(SS_YAML_KEY_SPINNING, m_floppyDrive[unit].spinning);
|
yamlSaveHelper.SaveUint(SS_YAML_KEY_SPINNING, m_floppyDrive[unit].m_spinning);
|
||||||
yamlSaveHelper.SaveUint(SS_YAML_KEY_WRITE_LIGHT, m_floppyDrive[unit].writelight);
|
yamlSaveHelper.SaveUint(SS_YAML_KEY_WRITE_LIGHT, m_floppyDrive[unit].m_writelight);
|
||||||
yamlSaveHelper.SaveHexUint16(SS_YAML_KEY_NIBBLES, m_floppyDrive[unit].disk.nibbles);
|
yamlSaveHelper.SaveHexUint16(SS_YAML_KEY_NIBBLES, m_floppyDrive[unit].m_disk.nibbles);
|
||||||
yamlSaveHelper.SaveUint(SS_YAML_KEY_TRACK_IMAGE_DATA, m_floppyDrive[unit].disk.trackimagedata);
|
yamlSaveHelper.SaveUint(SS_YAML_KEY_TRACK_IMAGE_DATA, m_floppyDrive[unit].m_disk.trackimagedata);
|
||||||
yamlSaveHelper.SaveUint(SS_YAML_KEY_TRACK_IMAGE_DIRTY, m_floppyDrive[unit].disk.trackimagedirty);
|
yamlSaveHelper.SaveUint(SS_YAML_KEY_TRACK_IMAGE_DIRTY, m_floppyDrive[unit].m_disk.trackimagedirty);
|
||||||
|
|
||||||
if (m_floppyDrive[unit].disk.trackimage)
|
if (m_floppyDrive[unit].m_disk.trackimage)
|
||||||
{
|
{
|
||||||
YamlSaveHelper::Label image(yamlSaveHelper, "%s:\n", SS_YAML_KEY_TRACK_IMAGE);
|
YamlSaveHelper::Label image(yamlSaveHelper, "%s:\n", SS_YAML_KEY_TRACK_IMAGE);
|
||||||
yamlSaveHelper.SaveMemory(m_floppyDrive[unit].disk.trackimage, NIBBLES_PER_TRACK);
|
yamlSaveHelper.SaveMemory(m_floppyDrive[unit].m_disk.trackimage, NIBBLES_PER_TRACK);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -1339,9 +1339,9 @@ void DiskIIInterfaceCard::LoadSnapshotDriveUnit(YamlLoadHelper& yamlLoadHelper,
|
|||||||
|
|
||||||
bool bImageError = false;
|
bool bImageError = false;
|
||||||
|
|
||||||
m_floppyDrive[unit].disk.fullname[0] = 0;
|
m_floppyDrive[unit].m_disk.fullname[0] = 0;
|
||||||
m_floppyDrive[unit].disk.imagename[0] = 0;
|
m_floppyDrive[unit].m_disk.imagename[0] = 0;
|
||||||
m_floppyDrive[unit].disk.bWriteProtected = false; // Default to false (until image is successfully loaded below)
|
m_floppyDrive[unit].m_disk.bWriteProtected = false; // Default to false (until image is successfully loaded below)
|
||||||
|
|
||||||
std::string filename = yamlLoadHelper.LoadString(SS_YAML_KEY_FILENAME);
|
std::string filename = yamlLoadHelper.LoadString(SS_YAML_KEY_FILENAME);
|
||||||
if (!filename.empty())
|
if (!filename.empty())
|
||||||
@ -1368,15 +1368,15 @@ void DiskIIInterfaceCard::LoadSnapshotDriveUnit(YamlLoadHelper& yamlLoadHelper,
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
m_floppyDrive[unit].track = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK);
|
m_floppyDrive[unit].m_track = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK);
|
||||||
m_floppyDrive[unit].phase = yamlLoadHelper.LoadUint(SS_YAML_KEY_PHASE);
|
m_floppyDrive[unit].m_phase = yamlLoadHelper.LoadUint(SS_YAML_KEY_PHASE);
|
||||||
m_floppyDrive[unit].disk.byte = yamlLoadHelper.LoadUint(SS_YAML_KEY_BYTE);
|
m_floppyDrive[unit].m_disk.byte = yamlLoadHelper.LoadUint(SS_YAML_KEY_BYTE);
|
||||||
yamlLoadHelper.LoadBool(SS_YAML_KEY_WRITE_PROTECTED); // Consume
|
yamlLoadHelper.LoadBool(SS_YAML_KEY_WRITE_PROTECTED); // Consume
|
||||||
m_floppyDrive[unit].spinning = yamlLoadHelper.LoadUint(SS_YAML_KEY_SPINNING);
|
m_floppyDrive[unit].m_spinning = yamlLoadHelper.LoadUint(SS_YAML_KEY_SPINNING);
|
||||||
m_floppyDrive[unit].writelight = yamlLoadHelper.LoadUint(SS_YAML_KEY_WRITE_LIGHT);
|
m_floppyDrive[unit].m_writelight = yamlLoadHelper.LoadUint(SS_YAML_KEY_WRITE_LIGHT);
|
||||||
m_floppyDrive[unit].disk.nibbles = yamlLoadHelper.LoadUint(SS_YAML_KEY_NIBBLES);
|
m_floppyDrive[unit].m_disk.nibbles = yamlLoadHelper.LoadUint(SS_YAML_KEY_NIBBLES);
|
||||||
m_floppyDrive[unit].disk.trackimagedata = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK_IMAGE_DATA) ? true : false;
|
m_floppyDrive[unit].m_disk.trackimagedata = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK_IMAGE_DATA) ? true : false;
|
||||||
m_floppyDrive[unit].disk.trackimagedirty = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK_IMAGE_DIRTY) ? true : false;
|
m_floppyDrive[unit].m_disk.trackimagedirty = yamlLoadHelper.LoadUint(SS_YAML_KEY_TRACK_IMAGE_DIRTY) ? true : false;
|
||||||
|
|
||||||
std::vector<BYTE> track(NIBBLES_PER_TRACK);
|
std::vector<BYTE> track(NIBBLES_PER_TRACK);
|
||||||
if (yamlLoadHelper.GetSubMap(SS_YAML_KEY_TRACK_IMAGE))
|
if (yamlLoadHelper.GetSubMap(SS_YAML_KEY_TRACK_IMAGE))
|
||||||
@ -1391,20 +1391,20 @@ void DiskIIInterfaceCard::LoadSnapshotDriveUnit(YamlLoadHelper& yamlLoadHelper,
|
|||||||
|
|
||||||
if (!filename.empty() && !bImageError)
|
if (!filename.empty() && !bImageError)
|
||||||
{
|
{
|
||||||
if ((m_floppyDrive[unit].disk.trackimage == NULL) && m_floppyDrive[unit].disk.nibbles)
|
if ((m_floppyDrive[unit].m_disk.trackimage == NULL) && m_floppyDrive[unit].m_disk.nibbles)
|
||||||
AllocTrack(unit);
|
AllocTrack(unit);
|
||||||
|
|
||||||
if (m_floppyDrive[unit].disk.trackimage == NULL)
|
if (m_floppyDrive[unit].m_disk.trackimage == NULL)
|
||||||
bImageError = true;
|
bImageError = true;
|
||||||
else
|
else
|
||||||
memcpy(m_floppyDrive[unit].disk.trackimage, &track[0], NIBBLES_PER_TRACK);
|
memcpy(m_floppyDrive[unit].m_disk.trackimage, &track[0], NIBBLES_PER_TRACK);
|
||||||
}
|
}
|
||||||
|
|
||||||
if (bImageError)
|
if (bImageError)
|
||||||
{
|
{
|
||||||
m_floppyDrive[unit].disk.trackimagedata = false;
|
m_floppyDrive[unit].m_disk.trackimagedata = false;
|
||||||
m_floppyDrive[unit].disk.trackimagedirty = false;
|
m_floppyDrive[unit].m_disk.trackimagedirty = false;
|
||||||
m_floppyDrive[unit].disk.nibbles = 0;
|
m_floppyDrive[unit].m_disk.nibbles = 0;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -78,26 +78,26 @@ struct Disk_t
|
|||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
struct Drive_t
|
struct FloppyDrive
|
||||||
{
|
{
|
||||||
int phase;
|
int m_phase;
|
||||||
int track;
|
int m_track;
|
||||||
DWORD spinning;
|
DWORD m_spinning;
|
||||||
DWORD writelight;
|
DWORD m_writelight;
|
||||||
Disk_t disk;
|
Disk_t m_disk;
|
||||||
|
|
||||||
Drive_t()
|
FloppyDrive()
|
||||||
{
|
{
|
||||||
clear();
|
clear();
|
||||||
}
|
}
|
||||||
|
|
||||||
void clear()
|
void clear()
|
||||||
{
|
{
|
||||||
phase = 0;
|
m_phase = 0;
|
||||||
track = 0;
|
m_track = 0;
|
||||||
spinning = 0;
|
m_spinning = 0;
|
||||||
writelight = 0;
|
m_writelight = 0;
|
||||||
disk.clear();
|
m_disk.clear();
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
@ -180,7 +180,7 @@ private:
|
|||||||
//
|
//
|
||||||
|
|
||||||
WORD m_currDrive;
|
WORD m_currDrive;
|
||||||
Drive_t m_floppyDrive[NUM_DRIVES];
|
FloppyDrive m_floppyDrive[NUM_DRIVES];
|
||||||
BYTE m_floppyLatch;
|
BYTE m_floppyLatch;
|
||||||
BOOL m_floppyMotorOn;
|
BOOL m_floppyMotorOn;
|
||||||
BOOL m_floppyLoadMode; // for efficiency this is not used; it's extremely unlikely to affect emulation (nickw)
|
BOOL m_floppyLoadMode; // for efficiency this is not used; it's extremely unlikely to affect emulation (nickw)
|
||||||
|
Loading…
Reference in New Issue
Block a user