コード例 #1
0
bool CapriceOpenDisk::HandleMessage(CMessage* pMessage)
{
	bool bHandled = false;
	if (pMessage)
	{
		switch(pMessage->MessageType())
        {
		case CMessage::CTRL_SINGLELCLICK:
		{
			if (pMessage->Destination() == this)
			{
				if (pMessage->Source() == m_pButtonCancel) {
					CloseFrame();
					CMessageServer::Instance().QueueMessage(new CMessage(CMessage::APP_EXIT, 0, this));
                    break;
                }
				if (pMessage->Source() == m_pButtonOpen) {
                    // Put selected ROM filename on button: (if there is a selection)
                    int selectedDiskIndex = m_pListBoxDisk->getFirstSelectedIndex();
                    if (selectedDiskIndex >= 0)
							{
                        DriveFile = (m_pListBoxDisk->GetItem(selectedDiskIndex)).sItemText;
                        if (selDrive) strncpy(CPC.drvB_file, DriveFile.c_str(), sizeof(CPC.drvB_file));
								else strncpy(CPC.drvA_file, DriveFile.c_str(), sizeof(CPC.drvA_file));
								std::string pchFile = DrivePath+DriveFile;
                        dsk_load(pchFile.c_str(),pDrive,'A');
								CloseFrame();
                        CMessageServer::Instance().QueueMessage(new CMessage(CMessage::APP_EXIT, 0, this));
                    }
                    break;
                }
				if (pMessage->Source() == m_pButtonClear)
				{
					if (selDrive)
					{
						strcpy(CPC.drvB_file, "");
					}
					else
					{
						strcpy(CPC.drvA_file, "");
					}
					dsk_eject(pDrive);
					CloseFrame();
					bHandled = true;
                    break;
                }
           		CMessageServer::Instance().QueueMessage(new CMessage(CMessage::APP_EXIT, 0, this));
			}
			break;
		}

		default :
			bHandled = CFrame::HandleMessage(pMessage);
			break;
		}
	}
	return bHandled;
}
コード例 #2
0
ファイル: slotshandler.cpp プロジェクト: sebhz/caprice32
int dsk_load (const std::string &filename, t_drive *drive)
{
   int iRetCode = 0;

   LOG_DEBUG("Loading disk: " << filename);
   dsk_eject(drive);
   if ((pfileObject = fopen(filename.c_str(), "rb")) != nullptr) {
     iRetCode = dsk_load(pfileObject, drive);
     fclose(pfileObject);
   } else {
      LOG_ERROR("File not found: " << filename);
      iRetCode = ERR_FILE_NOT_FOUND;
   }

   if (iRetCode != 0) { // on error, 'eject' disk from drive
      dsk_eject(drive);
   }
   return iRetCode;
}
コード例 #3
0
ファイル: slotshandler.cpp プロジェクト: sebhz/caprice32
int dsk_load (FILE *pfile, t_drive *drive)
{
  LOG_DEBUG("Loading disk");
  dword dwTrackSize, track, side, sector, dwSectorSize, dwSectors;
  byte *pbPtr, *pbDataPtr, *pbTempPtr, *pbTrackSizeTable;
  if(fread(pbGPBuffer, 0x100, 1, pfile) != 1) { // read DSK header
    LOG_ERROR("Couldn't read DSK header");
    return ERR_DSK_INVALID;
  }
  pbPtr = pbGPBuffer;

  if (memcmp(pbPtr, "MV - CPC", 8) == 0) { // normal DSK image?
    LOG_DEBUG("Loading normal disk");
    drive->tracks = *(pbPtr + 0x30); // grab number of tracks
    if (drive->tracks > DSK_TRACKMAX) { // compare against upper limit
      drive->tracks = DSK_TRACKMAX; // limit to maximum
    }
    drive->sides = *(pbPtr + 0x31); // grab number of sides
    if (drive->sides > DSK_SIDEMAX) { // abort if more than maximum
      LOG_ERROR("DSK header has " << drive->sides << " sides, expected " << DSK_SIDEMAX << " or less");
      dsk_eject(drive);
      return ERR_DSK_SIDES;
    }
    dwTrackSize = (*(pbPtr + 0x32) + (*(pbPtr + 0x33) << 8)) - 0x100; // determine track size in bytes, minus track header
    drive->sides--; // zero base number of sides
    for (track = 0; track < drive->tracks; track++) { // loop for all tracks
      for (side = 0; side <= drive->sides; side++) { // loop for all sides
        if(fread(pbGPBuffer+0x100, 0x100, 1, pfile) != 1) { // read track header
          LOG_ERROR("Couldn't read DSK track header for track " << track << " side " << side);
          dsk_eject(drive);
          return ERR_DSK_INVALID;
        }
        pbPtr = pbGPBuffer + 0x100;
        if (memcmp(pbPtr, "Track-Info", 10) != 0) { // abort if ID does not match
          LOG_ERROR("Corrupted DSK track header for track " << track << " side " << side);
          dsk_eject(drive);
          return ERR_DSK_INVALID;
        }
        dwSectorSize = 0x80 << *(pbPtr + 0x14); // determine sector size in bytes
        dwSectors = *(pbPtr + 0x15); // grab number of sectors
        if (dwSectors > DSK_SECTORMAX) { // abort if sector count greater than maximum
          LOG_ERROR("DSK track with " << dwSectors << " sectors, expected " << DSK_SECTORMAX << "or less");
          dsk_eject(drive);
          return ERR_DSK_SECTORS;
        }
        drive->track[track][side].sectors = dwSectors; // store sector count
        drive->track[track][side].size = dwTrackSize; // store track size
        drive->track[track][side].data = static_cast<byte *>(malloc(dwTrackSize)); // attempt to allocate the required memory
        if (drive->track[track][side].data == nullptr) { // abort if not enough
          LOG_ERROR("Couldn't allocate " << dwTrackSize << " bytes to store track " << track << " side " << side);
          dsk_eject(drive);
          return ERR_OUT_OF_MEMORY;
        }
        pbDataPtr = drive->track[track][side].data; // pointer to start of memory buffer
        pbTempPtr = pbDataPtr; // keep a pointer to the beginning of the buffer for the current track
        for (sector = 0; sector < dwSectors; sector++) { // loop for all sectors
          memcpy(drive->track[track][side].sector[sector].CHRN, (pbPtr + 0x18), 4); // copy CHRN
          memcpy(drive->track[track][side].sector[sector].flags, (pbPtr + 0x1c), 2); // copy ST1 & ST2
          drive->track[track][side].sector[sector].setSizes(dwSectorSize, dwSectorSize);
          drive->track[track][side].sector[sector].setData(pbDataPtr); // store pointer to sector data
          pbDataPtr += dwSectorSize;
          pbPtr += 8;
        }
        if (dwTrackSize > 0 && !fread(pbTempPtr, dwTrackSize, 1, pfile)) { // read entire track data in one go
          LOG_ERROR("Couldn't read track data for track " << track << " side " << side);
          dsk_eject(drive);
          return ERR_DSK_INVALID;
        }
      }
    }
    drive->altered = 0; // disk is as yet unmodified
  } else {
    if (memcmp(pbPtr, "EXTENDED", 8) == 0) { // extended DSK image?
      LOG_DEBUG("Loading extended disk");
      drive->tracks = *(pbPtr + 0x30); // number of tracks
      LOG_DEBUG("with " << drive->tracks << " tracks");
      if (drive->tracks > DSK_TRACKMAX) {  // limit to maximum possible
        drive->tracks = DSK_TRACKMAX;
      }
      drive->random_DEs = *(pbPtr + 0x31) & 0x80; // simulate random Data Errors?
      drive->sides = *(pbPtr + 0x31) & 3; // number of sides
      LOG_DEBUG("with " << drive->sides << " sides");
      if (drive->sides > DSK_SIDEMAX) { // abort if more than maximum
        LOG_ERROR("DSK header has " << drive->sides << " sides, expected " << DSK_SIDEMAX << " or less");
        dsk_eject(drive);
        return ERR_DSK_SIDES;
      }
      pbTrackSizeTable = pbPtr + 0x34; // pointer to track size table in DSK header
      drive->sides--; // zero base number of sides
      for (track = 0; track < drive->tracks; track++) { // loop for all tracks
        for (side = 0; side <= drive->sides; side++) { // loop for all sides
          dwTrackSize = (*pbTrackSizeTable++ << 8); // track size in bytes
          LOG_DEBUG("Track " << track << ", side " << side << ", size " << dwTrackSize);
          if (dwTrackSize != 0) { // only process if track contains data
            dwTrackSize -= 0x100; // compensate for track header
            if(fread(pbGPBuffer+0x100, 0x100, 1, pfile) != 1) { // read track header
              LOG_ERROR("Couldn't read DSK track header for track " << track << " side " << side);
              dsk_eject(drive);
              return ERR_DSK_INVALID;
            }
            pbPtr = pbGPBuffer + 0x100;
            if (memcmp(pbPtr, "Track-Info", 10) != 0) { // valid track header?
              LOG_ERROR("Corrupted DSK track header for track " << track << " side " << side);
              dsk_eject(drive);
              return ERR_DSK_INVALID;
            }
            dwSectors = *(pbPtr + 0x15); // number of sectors for this track
            LOG_DEBUG("with " << dwSectors << " sectors");
            if (dwSectors > DSK_SECTORMAX) { // abort if sector count greater than maximum
              LOG_ERROR("DSK track with " << dwSectors << " sectors, expected " << DSK_SECTORMAX << "or less");
              dsk_eject(drive);
              return ERR_DSK_SECTORS;
            }
            drive->track[track][side].sectors = dwSectors; // store sector count
            drive->track[track][side].size = dwTrackSize; // store track size
            drive->track[track][side].data = static_cast<byte *>(malloc(dwTrackSize)); // attempt to allocate the required memory
            if (drive->track[track][side].data == nullptr) { // abort if not enough
              LOG_ERROR("Couldn't allocate " << dwTrackSize << " bytes to store track " << track << " side " << side);
              dsk_eject(drive);
              return ERR_OUT_OF_MEMORY;
            }
            pbDataPtr = drive->track[track][side].data; // pointer to start of memory buffer
            pbTempPtr = pbDataPtr; // keep a pointer to the beginning of the buffer for the current track
            pbPtr += 0x18;
            for (sector = 0; sector < dwSectors; sector++) { // loop for all sectors
              memcpy(drive->track[track][side].sector[sector].CHRN, pbPtr, 4); // copy CHRN
              memcpy(drive->track[track][side].sector[sector].flags, (pbPtr + 0x04), 2); // copy ST1 & ST2
              dword dwRealSize = 0x80 << *(pbPtr+0x03);
              dwSectorSize = *(pbPtr + 0x6) + (*(pbPtr + 0x7) << 8); // sector size in bytes
              drive->track[track][side].sector[sector].setSizes(dwRealSize, dwSectorSize);
              drive->track[track][side].sector[sector].setData(pbDataPtr); // store pointer to sector data
              pbDataPtr += dwSectorSize;
              pbPtr += 8;
              LOG_DEBUG("Sector " << sector << " size: " << dwSectorSize << " real size: " << dwRealSize << " CHRN: " << chrn_to_string(drive->track[track][side].sector[sector].CHRN));
            }
            if (dwTrackSize > 0 && !fread(pbTempPtr, dwTrackSize, 1, pfile)) { // read entire track data in one go
              LOG_ERROR("Couldn't read track data for track " << track << " side " << side);
              dsk_eject(drive);
              return ERR_DSK_INVALID;
            }
          } else {
            LOG_DEBUG("empty track");
            memset(&drive->track[track][side], 0, sizeof(t_track)); // track not formatted
          }
        }
      }
      drive->altered = 0; // disk is as yet unmodified
    } else {
      LOG_ERROR("Unknown DSK type");
      dsk_eject(drive);
      return ERR_DSK_INVALID; // file could not be identified as a valid DSK
    }
  }
  return 0;
}