Apple-2-Tools
/
AppleWin
mirror of https://github.com/AppleWin/AppleWin.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Added: DiskEject() DiskProtect()

This commit is contained in:
mpohoreski 2006-02-26 02:02:57 +00:00
parent f48f7bc052
commit 15a6c00bd5
2 changed files with 211 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

332
AppleWin/source/Disk.cpp
View File

@ -29,53 +29,64 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#include "StdAfx.h" #include "StdAfx.h"
#pragma hdrstop #pragma hdrstop
typedef struct _floppyrec { // Public _________________________________________________________________________________________
TCHAR imagename[16];
TCHAR fullname[128]; BOOL enhancedisk = 1;
HIMAGE imagehandle;
int track; // Private ________________________________________________________________________________________
LPBYTE trackimage;
int phase; const int MAX_DISK_IMAGE_NAME = 15;
int byte; const int MAX_DISK_FULL_NAME = 127;
BOOL writeprotected;
BOOL trackimagedata; struct Disk_t
BOOL trackimagedirty; {
DWORD spinning; TCHAR imagename[ MAX_DISK_IMAGE_NAME + 1 ];
DWORD writelight; TCHAR fullname [ MAX_DISK_FULL_NAME + 1 ];
int nibbles; HIMAGE imagehandle;
} floppyrec, *floppyptr; int track;
LPBYTE trackimage;
int phase;
int byte;
BOOL writeprotected;
BOOL trackimagedata;
BOOL trackimagedirty;
DWORD spinning;
DWORD writelight;
int nibbles;
};
static int currdrive = 0; static int currdrive = 0;
static BOOL diskaccessed = 0; static BOOL diskaccessed = 0;
BOOL enhancedisk = 1; static Disk_t g_aFloppyDisk[DRIVES];
static floppyrec floppy[DRIVES];
static BYTE floppylatch = 0; static BYTE floppylatch = 0;
static BOOL floppymotoron = 0; static BOOL floppymotoron = 0;
static BOOL floppywritemode = 0; static BOOL floppywritemode = 0;
static void ChecSpinning();
static void ReadTrack (int drive); static void ReadTrack (int drive);
static void RemoveDisk (int drive); static void RemoveDisk (int drive);
static void WriteTrack (int drive); static void WriteTrack (int drive);
//=========================================================================== //===========================================================================
void CheckSpinning () { void CheckSpinning () {
DWORD modechange = (floppymotoron && !floppy[currdrive].spinning); DWORD modechange = (floppymotoron && !g_aFloppyDisk[currdrive].spinning);
if (floppymotoron) if (floppymotoron)
floppy[currdrive].spinning = 20000; g_aFloppyDisk[currdrive].spinning = 20000;
if (modechange) if (modechange)
FrameRefreshStatus(DRAW_LEDS); FrameRefreshStatus(DRAW_LEDS);
} }
//=========================================================================== //===========================================================================
void GetImageTitle (LPCTSTR imagefilename, floppyptr fptr) { void GetImageTitle (LPCTSTR imagefilename, Disk_t * fptr)
TCHAR imagetitle[128]; {
LPCTSTR startpos = imagefilename; TCHAR imagetitle[ MAX_DISK_FULL_NAME+1 ];
LPCTSTR startpos = imagefilename;
// imagetitle = <FILENAME.EXT> // imagetitle = <FILENAME.EXT>
if (_tcsrchr(startpos,TEXT('\\'))) if (_tcsrchr(startpos,TEXT('\\')))
startpos = _tcsrchr(startpos,TEXT('\\'))+1; startpos = _tcsrchr(startpos,TEXT('\\'))+1;
_tcsncpy(imagetitle,startpos,127); _tcsncpy(imagetitle,startpos,MAX_DISK_FULL_NAME);
imagetitle[127] = 0; imagetitle[MAX_DISK_FULL_NAME] = 0;
// if imagetitle contains a lowercase char, then found=1 (why?) // if imagetitle contains a lowercase char, then found=1 (why?)
BOOL found = 0; BOOL found = 0;
@ -92,8 +103,8 @@ void GetImageTitle (LPCTSTR imagefilename, floppyptr fptr) {
CharLowerBuff(imagetitle+1,_tcslen(imagetitle+1)); CharLowerBuff(imagetitle+1,_tcslen(imagetitle+1));
// fptr->fullname = <FILENAME.EXT> // fptr->fullname = <FILENAME.EXT>
_tcsncpy(fptr->fullname,imagetitle,127); _tcsncpy( fptr->fullname, imagetitle, MAX_DISK_FULL_NAME );
fptr->fullname[127] = 0; fptr->fullname[ MAX_DISK_FULL_NAME ] = 0;
if (imagetitle[0]) if (imagetitle[0])
{ {
@ -104,67 +115,109 @@ void GetImageTitle (LPCTSTR imagefilename, floppyptr fptr) {
*dot = 0; *dot = 0;
} }
// fptr->imagename = <FILENAME> (ie. no extension) // fptr->imagename = <FILENAME> (ie. no extension)
_tcsncpy(fptr->imagename,imagetitle,15); _tcsncpy( fptr->imagename, imagetitle, MAX_DISK_IMAGE_NAME );
fptr->imagename[15] = 0; fptr->imagename[ MAX_DISK_IMAGE_NAME ] = 0;
} }
//===========================================================================
bool IsDriveValid( const int iDrive )
{
if (iDrive < 0)
return false;
if (iDrive >= DRIVES)
return false;
return true;
}
//=========================================================================== //===========================================================================
static void AllocTrack(int drive) static void AllocTrack(int drive)
{ {
floppyptr fptr = &floppy[drive]; Disk_t * fptr = &g_aFloppyDisk[drive];
fptr->trackimage = (LPBYTE)VirtualAlloc(NULL,NIBBLES_PER_TRACK,MEM_COMMIT,PAGE_READWRITE); fptr->trackimage = (LPBYTE)VirtualAlloc(NULL,NIBBLES_PER_TRACK,MEM_COMMIT,PAGE_READWRITE);
} }
//=========================================================================== //===========================================================================
static void ReadTrack (int drive) { static void ReadTrack (int iDrive)
floppyptr fptr = &floppy[drive]; {
if (fptr->track >= TRACKS) { if (! IsDriveValid( iDrive ))
fptr->trackimagedata = 0; return;
return;
} Disk_t *pFloppy = &g_aFloppyDisk[ iDrive ];
if (!fptr->trackimage)
AllocTrack(drive); if (pFloppy->track >= TRACKS)
if (fptr->trackimage && fptr->imagehandle) { {
ImageReadTrack(fptr->imagehandle, pFloppy->trackimagedata = 0;
fptr->track, return;
fptr->phase, }
fptr->trackimage,
&fptr->nibbles); if (! pFloppy->trackimage)
fptr->byte = 0; AllocTrack( iDrive );
fptr->trackimagedata = (fptr->nibbles != 0);
} if (pFloppy->trackimage && pFloppy->imagehandle)
{
ImageReadTrack(
pFloppy->imagehandle,
pFloppy->track,
pFloppy->phase,
pFloppy->trackimage,
&pFloppy->nibbles);
pFloppy->byte = 0;
pFloppy->trackimagedata = (pFloppy->nibbles != 0);
}
} }
//=========================================================================== //===========================================================================
static void RemoveDisk (int drive) { static void RemoveDisk (int iDrive)
floppyptr fptr = &floppy[drive]; {
if (fptr->imagehandle) { Disk_t *pFloppy = &g_aFloppyDisk[iDrive];
if (fptr->trackimage && fptr->trackimagedirty)
WriteTrack(drive); if (pFloppy->imagehandle)
ImageClose(fptr->imagehandle); {
fptr->imagehandle = (HIMAGE)0; if (pFloppy->trackimage && pFloppy->trackimagedirty)
} WriteTrack( iDrive);
if (fptr->trackimage) {
VirtualFree(fptr->trackimage,0,MEM_RELEASE); ImageClose(pFloppy->imagehandle);
fptr->trackimage = NULL; pFloppy->imagehandle = (HIMAGE)0;
fptr->trackimagedata = 0; }
}
if (pFloppy->trackimage)
{
VirtualFree(pFloppy->trackimage,0,MEM_RELEASE);
pFloppy->trackimage = NULL;
pFloppy->trackimagedata = 0;
}
memset( pFloppy->imagename, 0, MAX_DISK_IMAGE_NAME+1 );
memset( pFloppy->fullname , 0, MAX_DISK_FULL_NAME +1 );
} }
//=========================================================================== //===========================================================================
static void WriteTrack (int drive) { static void WriteTrack (int iDrive)
floppyptr fptr = &floppy[drive]; {
if (fptr->track >= TRACKS) Disk_t *pFloppy = &g_aFloppyDisk[ iDrive ];
return;
if (fptr->trackimage && fptr->imagehandle) if (pFloppy->track >= TRACKS)
ImageWriteTrack(fptr->imagehandle, return;
fptr->track,
fptr->phase, if (pFloppy->writeprotected)
fptr->trackimage, return;
fptr->nibbles);
fptr->trackimagedirty = 0; if (pFloppy->trackimage && pFloppy->imagehandle)
ImageWriteTrack(
pFloppy->imagehandle,
pFloppy->track,
pFloppy->phase,
pFloppy->trackimage,
pFloppy->nibbles );
pFloppy->trackimagedirty = 0;
} }
// //
@ -176,7 +229,7 @@ void DiskBoot () {
// 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 (floppy[0].imagehandle && ImageBoot(floppy[0].imagehandle)) if (g_aFloppyDisk[0].imagehandle && ImageBoot(g_aFloppyDisk[0].imagehandle))
floppymotoron = 0; floppymotoron = 0;
} }
@ -190,7 +243,7 @@ BYTE __stdcall DiskControlMotor (WORD, BYTE address, BYTE, BYTE, ULONG) {
//=========================================================================== //===========================================================================
BYTE __stdcall DiskControlStepper (WORD, BYTE address, BYTE, BYTE, ULONG) { BYTE __stdcall DiskControlStepper (WORD, BYTE address, BYTE, BYTE, ULONG) {
floppyptr fptr = &floppy[currdrive]; Disk_t * fptr = &g_aFloppyDisk[currdrive];
if (address & 1) { if (address & 1) {
int phase = (address >> 1) & 3; int phase = (address >> 1) & 3;
int direction = 0; int direction = 0;
@ -215,45 +268,57 @@ BYTE __stdcall DiskControlStepper (WORD, BYTE address, BYTE, BYTE, ULONG) {
} }
//=========================================================================== //===========================================================================
void DiskDestroy () { void DiskDestroy ()
RemoveDisk(0); {
RemoveDisk(1); RemoveDisk(0);
RemoveDisk(1);
} }
//=========================================================================== //===========================================================================
BYTE __stdcall DiskEnable (WORD, BYTE address, BYTE, BYTE, ULONG) { BYTE __stdcall DiskEnable (WORD, BYTE address, BYTE, BYTE, ULONG) {
currdrive = address & 1; currdrive = address & 1;
floppy[!currdrive].spinning = 0; g_aFloppyDisk[!currdrive].spinning = 0;
floppy[!currdrive].writelight = 0; g_aFloppyDisk[!currdrive].writelight = 0;
CheckSpinning(); CheckSpinning();
return 0; return 0;
} }
//===========================================================================
void DiskEject( const int iDrive )
{
if (IsDriveValid( iDrive ))
{
RemoveDisk( iDrive );
}
}
//=========================================================================== //===========================================================================
LPCTSTR DiskGetFullName (int drive) { LPCTSTR DiskGetFullName (int drive) {
return floppy[drive].fullname; return g_aFloppyDisk[drive].fullname;
} }
//=========================================================================== //===========================================================================
void DiskGetLightStatus (int *drive1, int *drive2) { void DiskGetLightStatus (int *drive1, int *drive2) {
*drive1 = floppy[0].spinning ? floppy[0].writelight ? 2 *drive1 = g_aFloppyDisk[0].spinning ? g_aFloppyDisk[0].writelight ? 2
: 1 : 1
: 0; : 0;
*drive2 = floppy[1].spinning ? floppy[1].writelight ? 2 *drive2 = g_aFloppyDisk[1].spinning ? g_aFloppyDisk[1].writelight ? 2
: 1 : 1
: 0; : 0;
} }
//=========================================================================== //===========================================================================
LPCTSTR DiskGetName (int drive) { LPCTSTR DiskGetName (int drive) {
return floppy[drive].imagename; return g_aFloppyDisk[drive].imagename;
} }
//=========================================================================== //===========================================================================
void DiskInitialize () { void DiskInitialize () {
int loop = DRIVES; int loop = DRIVES;
while (loop--) while (loop--)
ZeroMemory(&floppy[loop],sizeof(floppyrec)); ZeroMemory(&g_aFloppyDisk[loop],sizeof(Disk_t ));
TCHAR imagefilename[MAX_PATH]; TCHAR imagefilename[MAX_PATH];
_tcscpy(imagefilename,progdir); _tcscpy(imagefilename,progdir);
_tcscat(imagefilename,TEXT("MASTER.DSK")); _tcscat(imagefilename,TEXT("MASTER.DSK"));
@ -262,10 +327,10 @@ void DiskInitialize () {
//=========================================================================== //===========================================================================
int DiskInsert (int drive, LPCTSTR imagefilename, BOOL writeprotected, BOOL createifnecessary) { int DiskInsert (int drive, LPCTSTR imagefilename, BOOL writeprotected, BOOL createifnecessary) {
floppyptr fptr = &floppy[drive]; Disk_t * fptr = &g_aFloppyDisk[drive];
if (fptr->imagehandle) if (fptr->imagehandle)
RemoveDisk(drive); RemoveDisk(drive);
ZeroMemory(fptr,sizeof(floppyrec)); ZeroMemory(fptr,sizeof(Disk_t ));
fptr->writeprotected = writeprotected; fptr->writeprotected = writeprotected;
int error = ImageOpen(imagefilename, int error = ImageOpen(imagefilename,
&fptr->imagehandle, &fptr->imagehandle,
@ -282,8 +347,10 @@ BOOL DiskIsSpinning () {
} }
//=========================================================================== //===========================================================================
void DiskNotifyInvalidImage (LPCTSTR imagefilename,int error) { void DiskNotifyInvalidImage (LPCTSTR imagefilename,int error)
TCHAR buffer[MAX_PATH+128]; {
TCHAR buffer[MAX_PATH+128];
switch (error) { switch (error) {
case 1: case 1:
@ -310,9 +377,21 @@ void DiskNotifyInvalidImage (LPCTSTR imagefilename,int error) {
MB_ICONEXCLAMATION | MB_SETFOREGROUND); MB_ICONEXCLAMATION | MB_SETFOREGROUND);
} }
//===========================================================================
void DiskProtect( const int iDrive, const bool bWriteProtect )
{
if (IsDriveValid( iDrive ))
{
Disk_t *pFloppy = &g_aFloppyDisk[ iDrive ];
pFloppy->writeprotected = bWriteProtect;
}
}
//=========================================================================== //===========================================================================
BYTE __stdcall DiskReadWrite (WORD programcounter, BYTE, BYTE, BYTE, ULONG) { BYTE __stdcall DiskReadWrite (WORD programcounter, BYTE, BYTE, BYTE, ULONG) {
floppyptr fptr = &floppy[currdrive]; Disk_t * fptr = &g_aFloppyDisk[currdrive];
diskaccessed = 1; diskaccessed = 1;
if ((!fptr->trackimagedata) && fptr->imagehandle) if ((!fptr->trackimagedata) && fptr->imagehandle)
ReadTrack(currdrive); ReadTrack(currdrive);
@ -401,14 +480,14 @@ BYTE __stdcall DiskSetLatchValue (WORD, BYTE, BYTE write, BYTE value, ULONG) {
//=========================================================================== //===========================================================================
BYTE __stdcall DiskSetReadMode (WORD, BYTE, BYTE, BYTE, ULONG) { BYTE __stdcall DiskSetReadMode (WORD, BYTE, BYTE, BYTE, ULONG) {
floppywritemode = 0; floppywritemode = 0;
return MemReturnRandomData(floppy[currdrive].writeprotected); return MemReturnRandomData(g_aFloppyDisk[currdrive].writeprotected);
} }
//=========================================================================== //===========================================================================
BYTE __stdcall DiskSetWriteMode (WORD, BYTE, BYTE, BYTE, ULONG) { BYTE __stdcall DiskSetWriteMode (WORD, BYTE, BYTE, BYTE, ULONG) {
floppywritemode = 1; floppywritemode = 1;
BOOL modechange = !floppy[currdrive].writelight; BOOL modechange = !g_aFloppyDisk[currdrive].writelight;
floppy[currdrive].writelight = 20000; g_aFloppyDisk[currdrive].writelight = 20000;
if (modechange) if (modechange)
FrameRefreshStatus(DRAW_LEDS); FrameRefreshStatus(DRAW_LEDS);
return MemReturnRandomData(1); return MemReturnRandomData(1);
@ -418,7 +497,7 @@ BYTE __stdcall DiskSetWriteMode (WORD, BYTE, BYTE, BYTE, ULONG) {
void DiskUpdatePosition (DWORD cycles) { void DiskUpdatePosition (DWORD cycles) {
int loop = 2; int loop = 2;
while (loop--) { while (loop--) {
floppyptr fptr = &floppy[loop]; Disk_t * fptr = &g_aFloppyDisk[loop];
if (fptr->spinning && !floppymotoron) { if (fptr->spinning && !floppymotoron) {
if (!(fptr->spinning -= MIN(fptr->spinning,(cycles >> 6)))) if (!(fptr->spinning -= MIN(fptr->spinning,(cycles >> 6))))
FrameRefreshStatus(DRAW_LEDS); FrameRefreshStatus(DRAW_LEDS);
@ -444,16 +523,17 @@ void DiskUpdatePosition (DWORD cycles) {
bool DiskDriveSwap() bool DiskDriveSwap()
{ {
// Refuse to swap if either Disk][ is active // Refuse to swap if either Disk][ is active
if(floppy[0].spinning || floppy[1].spinning) if(g_aFloppyDisk[0].spinning || g_aFloppyDisk[1].spinning)
return false; return false;
// Swap disks between drives // Swap disks between drives
floppyrec fr; Disk_t temp;
// Swap trackimage ptrs (so don't need to swap the buffers' data) // Swap trackimage ptrs (so don't need to swap the buffers' data)
memcpy(&fr, &floppy[0], sizeof(floppyrec)); // TODO: Array of Pointers: Disk_t* g_aDrive[]
memcpy(&floppy[0], &floppy[1], sizeof(floppyrec)); memcpy(&temp , &g_aFloppyDisk[0], sizeof(Disk_t ));
memcpy(&floppy[1], &fr, sizeof(floppyrec)); memcpy(&g_aFloppyDisk[0], &g_aFloppyDisk[1], sizeof(Disk_t ));
memcpy(&g_aFloppyDisk[1], &temp , sizeof(Disk_t ));
FrameRefreshStatus(DRAW_LEDS | DRAW_BUTTON_DRIVES); FrameRefreshStatus(DRAW_LEDS | DRAW_BUTTON_DRIVES);
@ -479,19 +559,19 @@ DWORD DiskGetSnapshot(SS_CARD_DISK2* pSS, DWORD dwSlot)
for(UINT i=0; i<2; i++) for(UINT i=0; i<2; i++)
{ {
strcpy(pSS->Unit[i].szFileName, floppy[i].fullname); strcpy(pSS->Unit[i].szFileName, g_aFloppyDisk[i].fullname);
pSS->Unit[i].track = floppy[i].track; pSS->Unit[i].track = g_aFloppyDisk[i].track;
pSS->Unit[i].phase = floppy[i].phase; pSS->Unit[i].phase = g_aFloppyDisk[i].phase;
pSS->Unit[i].byte = floppy[i].byte; pSS->Unit[i].byte = g_aFloppyDisk[i].byte;
pSS->Unit[i].writeprotected = floppy[i].writeprotected; pSS->Unit[i].writeprotected = g_aFloppyDisk[i].writeprotected;
pSS->Unit[i].trackimagedata = floppy[i].trackimagedata; pSS->Unit[i].trackimagedata = g_aFloppyDisk[i].trackimagedata;
pSS->Unit[i].trackimagedirty = floppy[i].trackimagedirty; pSS->Unit[i].trackimagedirty = g_aFloppyDisk[i].trackimagedirty;
pSS->Unit[i].spinning = floppy[i].spinning; pSS->Unit[i].spinning = g_aFloppyDisk[i].spinning;
pSS->Unit[i].writelight = floppy[i].writelight; pSS->Unit[i].writelight = g_aFloppyDisk[i].writelight;
pSS->Unit[i].nibbles = floppy[i].nibbles; pSS->Unit[i].nibbles = g_aFloppyDisk[i].nibbles;
if(floppy[i].trackimage) if(g_aFloppyDisk[i].trackimage)
memcpy(pSS->Unit[i].nTrack, floppy[i].trackimage, NIBBLES_PER_TRACK); memcpy(pSS->Unit[i].nTrack, g_aFloppyDisk[i].trackimage, NIBBLES_PER_TRACK);
else else
memset(pSS->Unit[i].nTrack, 0, NIBBLES_PER_TRACK); memset(pSS->Unit[i].nTrack, 0, NIBBLES_PER_TRACK);
} }
@ -515,7 +595,7 @@ DWORD DiskSetSnapshot(SS_CARD_DISK2* pSS, DWORD /*dwSlot*/)
{ {
bool bImageError = false; bool bImageError = false;
ZeroMemory(&floppy[i], sizeof(floppyrec)); ZeroMemory(&g_aFloppyDisk[i], sizeof(Disk_t ));
if(pSS->Unit[i].szFileName[0] == 0x00) if(pSS->Unit[i].szFileName[0] == 0x00)
continue; continue;
@ -545,35 +625,35 @@ DWORD DiskSetSnapshot(SS_CARD_DISK2* pSS, DWORD /*dwSlot*/)
// //
// strcpy(floppy[i].fullname, pSS->Unit[i].szFileName); // strcpy(g_aFloppyDisk[i].fullname, pSS->Unit[i].szFileName);
floppy[i].track = pSS->Unit[i].track; g_aFloppyDisk[i].track = pSS->Unit[i].track;
floppy[i].phase = pSS->Unit[i].phase; g_aFloppyDisk[i].phase = pSS->Unit[i].phase;
floppy[i].byte = pSS->Unit[i].byte; g_aFloppyDisk[i].byte = pSS->Unit[i].byte;
// floppy[i].writeprotected = pSS->Unit[i].writeprotected; // g_aFloppyDisk[i].writeprotected = pSS->Unit[i].writeprotected;
floppy[i].trackimagedata = pSS->Unit[i].trackimagedata; g_aFloppyDisk[i].trackimagedata = pSS->Unit[i].trackimagedata;
floppy[i].trackimagedirty = pSS->Unit[i].trackimagedirty; g_aFloppyDisk[i].trackimagedirty = pSS->Unit[i].trackimagedirty;
floppy[i].spinning = pSS->Unit[i].spinning; g_aFloppyDisk[i].spinning = pSS->Unit[i].spinning;
floppy[i].writelight = pSS->Unit[i].writelight; g_aFloppyDisk[i].writelight = pSS->Unit[i].writelight;
floppy[i].nibbles = pSS->Unit[i].nibbles; g_aFloppyDisk[i].nibbles = pSS->Unit[i].nibbles;
// //
if(!bImageError) if(!bImageError)
{ {
if((floppy[i].trackimage == NULL) && floppy[i].nibbles) if((g_aFloppyDisk[i].trackimage == NULL) && g_aFloppyDisk[i].nibbles)
AllocTrack(i); AllocTrack(i);
if(floppy[i].trackimage == NULL) if(g_aFloppyDisk[i].trackimage == NULL)
bImageError = true; bImageError = true;
else else
memcpy(floppy[i].trackimage, pSS->Unit[i].nTrack, NIBBLES_PER_TRACK); memcpy(g_aFloppyDisk[i].trackimage, pSS->Unit[i].nTrack, NIBBLES_PER_TRACK);
} }
if(bImageError) if(bImageError)
{ {
floppy[i].trackimagedata = 0; g_aFloppyDisk[i].trackimagedata = 0;
floppy[i].trackimagedirty = 0; g_aFloppyDisk[i].trackimagedirty = 0;
floppy[i].nibbles = 0; g_aFloppyDisk[i].nibbles = 0;
} }
} }

7
AppleWin/source/Disk.h
View File

@ -8,16 +8,19 @@
extern BOOL enhancedisk; extern BOOL enhancedisk;
void DiskInitialize (); // DiskManagerStartup()
void DiskDestroy (); // no, doesn't "destroy" the disk image. DiskManagerShutdown()
void DiskBoot (); void DiskBoot ();
void DiskDestroy (); void DiskEject( const int iDrive );
LPCTSTR DiskGetFullName (int); LPCTSTR DiskGetFullName (int);
void DiskGetLightStatus (int *,int *); void DiskGetLightStatus (int *,int *);
LPCTSTR DiskGetName (int); LPCTSTR DiskGetName (int);
void DiskInitialize ();
int DiskInsert (int,LPCTSTR,BOOL,BOOL); int DiskInsert (int,LPCTSTR,BOOL,BOOL);
BOOL DiskIsSpinning (); BOOL DiskIsSpinning ();
void DiskNotifyInvalidImage (LPCTSTR,int); void DiskNotifyInvalidImage (LPCTSTR,int);
void DiskReset (); void DiskReset ();
void DiskProtect( const int iDrive, const bool bWriteProtect );
void DiskSelect (int); void DiskSelect (int);
void DiskUpdatePosition (DWORD); void DiskUpdatePosition (DWORD);
bool DiskDriveSwap(); bool DiskDriveSwap();