c64
/
pi1541
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
pi1541/FileBrowser.cpp

933 lines
24 KiB
C++
Raw Blame History

// Pi1541 - A Commodore 1541 disk drive emulator
// Copyright(C) 2018 Stephen White
//
// This file is part of Pi1541.
//
// Pi1541 is free software : you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Pi1541 is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Pi1541. If not, see <http://www.gnu.org/licenses/>.
#include "FileBrowser.h"
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <algorithm>
#include "Screen.h"
#include "debug.h"
#include "Keyboard.h"
#include "options.h"
#include "InputMappings.h"
#include "stb_image.h"
#include "Petscii.h"
extern "C"
{
#include "rpi-gpio.h"
}
extern Screen screen;
#define PNG_WIDTH 320
#define PNG_HEIGHT 200
unsigned char FileBrowser::LSTBuffer[FileBrowser::LSTBuffer_size];
const unsigned FileBrowser::SwapKeys[30] =
{
KEY_F1, KEY_KP1, KEY_1,
KEY_F2, KEY_KP2, KEY_2,
KEY_F3, KEY_KP3, KEY_3,
KEY_F4, KEY_KP4, KEY_4,
KEY_F5, KEY_KP5, KEY_5,
KEY_F6, KEY_KP6, KEY_6,
KEY_F7, KEY_KP7, KEY_7,
KEY_F8, KEY_KP8, KEY_8,
KEY_F9, KEY_KP9, KEY_9,
KEY_F10, KEY_KP0, KEY_0
};
static const u32 palette[] =
{
RGBA(0x00, 0x00, 0x00, 0xFF),
RGBA(0xFF, 0xFF, 0xFF, 0xFF),
RGBA(0x88, 0x39, 0x32, 0xFF),
RGBA(0x67, 0xB6, 0xBD, 0xFF),
RGBA(0x8B, 0x4F, 0x96, 0xFF),
RGBA(0x55, 0xA0, 0x49, 0xFF),
RGBA(0x40, 0x31, 0x8D, 0xFF),
RGBA(0xBF, 0xCE, 0x72, 0xFF),
RGBA(0x8B, 0x54, 0x29, 0xFF),
RGBA(0x57, 0x42, 0x00, 0xFF),
RGBA(0xB8, 0x69, 0x62, 0xFF),
RGBA(0x50, 0x50, 0x50, 0xFF),
RGBA(0x78, 0x78, 0x78, 0xFF),
RGBA(0x94, 0xE0, 0x89, 0xFF),
RGBA(0x78, 0x69, 0xC4, 0xFF),
RGBA(0x9F, 0x9F, 0x9F, 0xFF)
};
FileBrowser::BrowsableList::Entry* FileBrowser::BrowsableList::FindEntry(const char* name)
{
int index;
int len = (int)entries.size();
for (index = 0; index < len; ++index)
{
Entry* entry = &entries[index];
if (!(entry->filImage.fattrib & AM_DIR) && strcasecmp(name, entry->filImage.fname) == 0)
return entry;
}
return 0;
}
FileBrowser::FileBrowser(DiskCaddy* diskCaddy, ROMs* roms, unsigned deviceID, bool displayPNGIcons)
: state(State_Folders)
, maxOnScreen(38)
, diskCaddy(diskCaddy)
, selectionsMade(false)
, roms(roms)
, deviceID(deviceID)
, displayPNGIcons(displayPNGIcons)
{
}
u32 FileBrowser::Colour(int index)
{
return palette[index & 0xf];
}
struct greater
{
bool operator()(const FileBrowser::BrowsableList::Entry& lhs, const FileBrowser::BrowsableList::Entry& rhs) const
{
if (strcasecmp(lhs.filImage.fname, "..") == 0)
return true;
else if (strcasecmp(rhs.filImage.fname, "..") == 0)
return false;
else if (((lhs.filImage.fattrib & AM_DIR) && (rhs.filImage.fattrib & AM_DIR)) || (!(lhs.filImage.fattrib & AM_DIR) && !(rhs.filImage.fattrib & AM_DIR)))
return strcasecmp(lhs.filImage.fname, rhs.filImage.fname) < 0;
else if ((lhs.filImage.fattrib & AM_DIR) && !(rhs.filImage.fattrib & AM_DIR))
return true;
else
return false;
}
};
void FileBrowser::RefreshFolderEntries()
{
DIR dir;
FileBrowser::BrowsableList::Entry entry;
FRESULT res;
char* ext;
folder.Clear();
res = f_opendir(&dir, ".");
if (res == FR_OK)
{
do
{
res = f_readdir(&dir, &entry.filImage);
ext = strrchr(entry.filImage.fname, '.');
if (res == FR_OK && entry.filImage.fname[0] != 0 && !(ext && strcasecmp(ext, ".png") == 0))
folder.entries.push_back(entry);
}
while (res == FR_OK && entry.filImage.fname[0] != 0);
f_closedir(&dir);
// Now check for icons
res = f_opendir(&dir, ".");
if (res == FR_OK)
{
do
{
res = f_readdir(&dir, &entry.filIcon);
ext = strrchr(entry.filIcon.fname, '.');
if (ext)
{
int length = ext - entry.filIcon.fname;
if (res == FR_OK && entry.filIcon.fname[0] != 0 && strcasecmp(ext, ".png") == 0)
{
for (unsigned index = 0; index < folder.entries.size(); ++index)
{
FileBrowser::BrowsableList::Entry* entryAtIndex = &folder.entries[index];
if (strncasecmp(entry.filIcon.fname, entryAtIndex->filImage.fname, length) == 0)
entryAtIndex->filIcon = entry.filIcon;
}
}
}
}
while (res == FR_OK && entry.filIcon.fname[0] != 0);
}
f_closedir(&dir);
strcpy(entry.filImage.fname, "..");
entry.filIcon.fname[0] = 0;
folder.entries.push_back(entry);
std::sort(folder.entries.begin(), folder.entries.end(), greater());
if (folder.entries.size() > 0) folder.current = &folder.entries[0];
else folder.current = 0;
folder.currentIndex = 0;
}
else
{
//DEBUG_LOG("Cannot open dir");
}
// incase they deleted something selected in the caddy
caddySelections.Clear();
}
void FileBrowser::FolderChanged()
{
RefreshFolderEntries();
RefeshDisplay();
}
void FileBrowser::DisplayRoot()
{
f_chdir("\\1541");
FolderChanged();
}
void FileBrowser::RefeshDisplayForBrowsableList(FileBrowser::BrowsableList* browsableList, int xOffset, bool showSelected)
{
char buffer1[128] = { 0 };
char buffer2[128] = { 0 };
u32 index;
u32 entryIndex;
u32 x = xOffset;
u32 y = 17;
u32 colour;
bool terminal = false;
RGBA BkColour = RGBA(0, 0, 0, 0xFF); //palette[VIC2_COLOUR_INDEX_BLUE];
if (terminal)
printf("\E[2J\E[f");
for (index = 0; index < maxOnScreen; ++index)
{
entryIndex = browsableList->offset + index;
if (entryIndex < browsableList->entries.size())
{
FileBrowser::BrowsableList::Entry* entry = &browsableList->entries[entryIndex];
snprintf(buffer2, 81, "%s", entry->filImage.fname);
memset(buffer1, ' ', 80);
buffer1[127] = 0;
strncpy(buffer1, buffer2, strlen(buffer2));
if (showSelected && browsableList->currentIndex == entryIndex)
{
if (entry->filImage.fattrib & AM_DIR)
{
if (terminal)
printf("\E[34;47m%s\E[0m\r\n", buffer1);
screen.PrintText(false, x, y, buffer1, palette[VIC2_COLOUR_INDEX_LBLUE], RGBA(0xff, 0xff, 0xff, 0xff));
}
else
{
colour = RGBA(0xff, 0, 0, 0xff);
if (entry->filImage.fattrib & AM_RDO)
colour = palette[VIC2_COLOUR_INDEX_RED];
screen.PrintText(false, x, y, buffer1, colour, RGBA(0xff, 0xff, 0xff, 0xff));
if (terminal)
printf("\E[31;47m%s\E[0m\r\n", buffer1);
}
}
else
{
if (entry->filImage.fattrib & AM_DIR)
{
screen.PrintText(false, x, y, buffer1, palette[VIC2_COLOUR_INDEX_LBLUE], BkColour);
if (terminal)
printf("\E[34m%s\E[0m\r\n", buffer1);
}
else
{
colour = palette[VIC2_COLOUR_INDEX_LGREY];
if (entry->filImage.fattrib & AM_RDO)
colour = palette[VIC2_COLOUR_INDEX_PINK];
screen.PrintText(false, x, y, buffer1, colour, BkColour);
if (terminal)
printf("\E[0;m%s\E[0m\r\n", buffer1);
}
}
}
else
{
memset(buffer1, ' ', 80);
screen.PrintText(false, x, y, buffer1, BkColour, BkColour);
if (terminal)
printf("%s\r\n", buffer1);
}
y += 16;
}
}
void FileBrowser::RefeshDisplay()
{
char buffer[1024];
if (f_getcwd(buffer, 1024) == FR_OK)
{
u32 textColour = Colour(VIC2_COLOUR_INDEX_LGREEN);
u32 bgColour = Colour(VIC2_COLOUR_INDEX_GREY);
screen.ClearArea(0, 0, (int)screen.Width(), 17, bgColour);
screen.PrintText(false, 0, 0, buffer, textColour, bgColour);
}
RefeshDisplayForBrowsableList(&folder, 0);
RefeshDisplayForBrowsableList(&caddySelections, 1024 - 320, false);
DisplayPNG();
DisplayStatusBar();
}
bool FileBrowser::CheckForPNG(const char* filename, FILINFO& filIcon)
{
bool foundValid = false;
filIcon.fname[0] = 0;
if (DiskImage::IsDiskImageExtention(filename))
{
char fileName[256];
char* ptr = strrchr(filename, '.');
if (ptr)
{
int len = ptr - filename;
strncpy(fileName, filename, len);
fileName[len] = 0;
strcat(fileName, ".png");
if (f_stat(fileName, &filIcon) == FR_OK && filIcon.fsize < FILEBROWSER_MAX_PNG_SIZE)
foundValid = true;
}
}
return foundValid;
}
void FileBrowser::DisplayPNG(FILINFO& filIcon, int x, int y)
{
if (filIcon.fname[0] != 0 && filIcon.fsize < FILEBROWSER_MAX_PNG_SIZE)
{
FIL fp;
FRESULT res;
res = f_open(&fp, filIcon.fname, FA_READ);
if (res == FR_OK)
{
u32 bytesRead;
SetACTLed(true);
f_read(&fp, PNG, FILEBROWSER_MAX_PNG_SIZE, &bytesRead);
SetACTLed(false);
f_close(&fp);
int w;
int h;
int channels_in_file;
stbi_uc* image = stbi_load_from_memory((stbi_uc const*)PNG, bytesRead, &w, &h, &channels_in_file, 4);
if (image && (w == PNG_WIDTH && h == PNG_HEIGHT))
{
//DEBUG_LOG("Opened PNG %s w = %d h = %d cif = %d\r\n", fileName, w, h, channels_in_file);
screen.PlotImage((u32*)image, x, y, w, h);
}
else
{
//DEBUG_LOG("Invalid PNG size %d x %d\r\n", w, h);
}
}
}
else
{
//DEBUG_LOG("Cannot find PNG %s\r\n", fileName);
}
}
void FileBrowser::DisplayPNG()
{
if (displayPNGIcons && folder.current)
{
FileBrowser::BrowsableList::Entry* current = folder.current;
DisplayPNG(current->filIcon, 1024 - 320, 426);
}
}
void FileBrowser::PopFolder()
{
f_chdir("..");
//{
// char buffer[1024];
// if (f_getcwd(buffer, 1024) == FR_OK)
// {
// DEBUG_LOG("CWD = %s\r\n", buffer);
// }
//}
RefreshFolderEntries();
caddySelections.Clear();
RefeshDisplay();
}
void FileBrowser::UpdateInput()
{
InputMappings* inputMappings = InputMappings::Instance();
Keyboard* keyboard = Keyboard::Instance();
bool dirty = false;
if (keyboard->CheckChanged())
dirty = inputMappings->CheckKeyboardBrowseMode();
else
dirty = inputMappings->CheckButtonsBrowseMode();
if (dirty)
{
//if (state == State_Folders)
UpdateInputFolders();
//else
// UpdateInputDiskCaddy();
}
}
FileBrowser::Folder* FileBrowser::GetCurrentFolder()
{
return &folder;
}
bool FileBrowser::FillCaddyWithSelections()
{
if (caddySelections.entries.size())
{
for (auto it = caddySelections.entries.begin(); it != caddySelections.entries.end();)
{
bool readOnly = ((*it).filImage.fattrib & AM_RDO) != 0;
if (diskCaddy->Insert(&(*it).filImage, readOnly) == false)
caddySelections.entries.erase(it);
else
it++;
}
return true;
}
return false;
}
bool FileBrowser::AddToCaddy(FileBrowser::BrowsableList::Entry* current)
{
bool added = false;
if (current && !(current->filImage.fattrib & AM_DIR) && DiskImage::IsDiskImageExtention(current->filImage.fname))
{
bool canAdd = true;
unsigned i;
for (i = 0; i < caddySelections.entries.size(); ++i)
{
if (strcmp(current->filImage.fname, caddySelections.entries[i].filImage.fname) == 0)
{
canAdd = false;
break;
}
}
if (canAdd)
{
caddySelections.entries.push_back(*current);
added = true;
}
}
return added;
}
void FileBrowser::UpdateInputFolders()
{
Keyboard* keyboard = Keyboard::Instance();
InputMappings* inputMappings = InputMappings::Instance();
if (folder.entries.size() > 0)
{
u32 numberOfEntriesMinus1 = folder.entries.size() - 1;
bool dirty = false;
if (inputMappings->BrowseSelect())
{
FileBrowser::BrowsableList::Entry* current = folder.current;
if (current)
{
if (current->filImage.fattrib & AM_DIR)
{
if (strcmp(current->filImage.fname, "..") == 0)
{
PopFolder();
}
else if (strcmp(current->filImage.fname, ".") != 0)
{
f_chdir(current->filImage.fname);
RefreshFolderEntries();
}
dirty = true;
}
else
{
if (strcmp(current->filImage.fname, "..") == 0)
{
PopFolder();
}
else if (DiskImage::IsDiskImageExtention(current->filImage.fname))
{
DiskImage::DiskType diskType = DiskImage::GetDiskImageTypeViaExtention(current->filImage.fname);
// Should also be able to create a LST file from all the images currently selected in the caddy
if (diskType == DiskImage::LST)
{
selectionsMade = SelectLST(current->filImage.fname);
}
else
{
// Add the current selected
AddToCaddy(current);
selectionsMade = FillCaddyWithSelections();
}
if (selectionsMade)
lastSelectionName = current->filImage.fname;
dirty = true;
}
}
}
}
else if (inputMappings->BrowseDone())
{
selectionsMade = FillCaddyWithSelections();
}
//else if (keyboard->KeyPressed(KEY_TAB))
//{
// state = State_DiskCaddy;
// dirty = true;
//}
else if (inputMappings->BrowseBack())
{
PopFolder();
dirty = true;
}
else if (inputMappings->Exit())
{
caddySelections.Clear();
dirty = true;
}
else if (inputMappings->BrowseInsert())
{
FileBrowser::BrowsableList::Entry* current = folder.current;
if (current)
{
dirty = AddToCaddy(current);
}
}
else
{
unsigned keySetIndex;
for (keySetIndex = 0; keySetIndex < ROMs::MAX_ROMS; ++keySetIndex)
{
unsigned keySetIndexBase = keySetIndex * 3;
if (keyboard->KeyPressed(FileBrowser::SwapKeys[keySetIndexBase]) || keyboard->KeyPressed(FileBrowser::SwapKeys[keySetIndexBase + 1]) || keyboard->KeyPressed(FileBrowser::SwapKeys[keySetIndexBase + 2]))
{
if (roms->ROMValid[keySetIndex])
{
roms->currentROMIndex = keySetIndex;
roms->lastManualSelectedROMIndex = keySetIndex;
DEBUG_LOG("Swap ROM %d %s\r\n", keySetIndex, roms->ROMNames[keySetIndex]);
ShowDeviceAndROM();
}
}
}
if (inputMappings->BrowseDown())
{
if (folder.currentIndex < numberOfEntriesMinus1)
{
folder.currentIndex++;
folder.current = &folder.entries[folder.currentIndex];
if (folder.currentIndex >= (folder.offset + maxOnScreen) && (folder.currentIndex < folder.entries.size()))
folder.offset++;
dirty = true;
}
}
if (inputMappings->BrowseUp())
{
if (folder.currentIndex > 0)
{
folder.currentIndex--;
folder.current = &folder.entries[folder.currentIndex];
if ((folder.offset > 0) && (folder.currentIndex < folder.offset))
folder.offset--;
dirty = true;
}
}
if (inputMappings->BrowsePageDown())
{
u32 maxOnScreenMinus1 = maxOnScreen - 1;
if (folder.currentIndex == folder.offset + maxOnScreenMinus1)
{
// Need to move the screen window down so that the currentIndex is now at the top of the screen
folder.offset = folder.currentIndex;
// Current index now becomes the bottom one
if (folder.offset + maxOnScreenMinus1 > numberOfEntriesMinus1)
folder.currentIndex = numberOfEntriesMinus1; // Not enough entries to move another page just move to the last entry
else // Move the window down a page
folder.currentIndex = folder.offset + maxOnScreenMinus1;
}
else
{
// Need to move to folder.offset + maxOnScreenMinus1
if (folder.offset + maxOnScreenMinus1 > numberOfEntriesMinus1)
folder.currentIndex = numberOfEntriesMinus1; // Run out of entries before we hit the bottom. Just move to the bottom.
else
folder.currentIndex = folder.offset + maxOnScreenMinus1; // Move the bottom of the screen
}
folder.current = &folder.entries[folder.currentIndex];
dirty = true;
}
if (inputMappings->BrowsePageUp())
{
if (folder.currentIndex == folder.offset)
{
// If the cursor is already at the top of the window then page up
int offset = (int)folder.currentIndex - (int)maxOnScreen;
if (offset < 0) folder.offset = 0;
else folder.offset = (u32)offset;
folder.currentIndex = folder.offset;
}
else
{
folder.currentIndex = folder.offset; // Move the cursor to the top of the window
}
folder.current = &folder.entries[folder.currentIndex];
dirty = true;
}
}
if (dirty) RefeshDisplay();
}
else
{
if (inputMappings->BrowseBack())
PopFolder();
}
}
bool FileBrowser::SelectLST(const char* filenameLST)
{
bool validImage = false;
//DEBUG_LOG("Selected %s\r\n", filenameLST);
if (DiskImage::IsLSTExtention(filenameLST))
{
FileBrowser::Folder* currentFolder = GetCurrentFolder();
if (currentFolder)
{
DiskImage::DiskType diskType;
FIL fp;
FRESULT res;
res = f_open(&fp, filenameLST, FA_READ);
if (res == FR_OK)
{
u32 bytesRead;
SetACTLed(true);
f_read(&fp, FileBrowser::LSTBuffer, FileBrowser::LSTBuffer_size, &bytesRead);
SetACTLed(false);
f_close(&fp);
TextParser textParser;
textParser.SetData((char*)FileBrowser::LSTBuffer);
char* token = textParser.GetToken(true);
while (token)
{
//DEBUG_LOG("LST token = %s\r\n", token);
diskType = DiskImage::GetDiskImageTypeViaExtention(token);
if (diskType == DiskImage::D64 || diskType == DiskImage::G64 || diskType == DiskImage::NIB || diskType == DiskImage::NBZ)
{
FileBrowser::BrowsableList::Entry* entry = currentFolder->FindEntry(token);
if (entry && !(entry->filImage.fattrib & AM_DIR))
{
bool readOnly = (entry->filImage.fattrib & AM_RDO) != 0;
if (diskCaddy->Insert(&entry->filImage, readOnly))
validImage = true;
}
}
else
{
roms->SelectROM(token);
}
token = textParser.GetToken(true);
}
}
}
}
return validImage;
}
// Not used
void FileBrowser::UpdateInputDiskCaddy()
{
bool dirty = false;
Keyboard* keyboard = Keyboard::Instance();
if (keyboard->KeyPressed(KEY_DELETE))
{
}
else if (keyboard->KeyPressed(KEY_TAB))
{
state = State_Folders;
dirty = true;
}
else
{
if (keyboard->KeyHeld(KEY_DOWN))
{
}
if (keyboard->KeyHeld(KEY_UP))
{
}
}
if (dirty) RefeshDisplay();
}
void FileBrowser::DisplayStatusBar()
{
u32 x = 0;
u32 y = STATUS_BAR_POSITION_Y;
char bufferOut[128];
snprintf(bufferOut, 256, "LED 0 Motor 0 Track 00.0 ATN 0 DAT 0 CLK 0");
screen.PrintText(false, x, y, bufferOut, RGBA(0, 0, 0, 0xff), RGBA(0xff, 0xff, 0xff, 0xff));
}
void FileBrowser::ClearScreen()
{
u32 bgColour = palette[VIC2_COLOUR_INDEX_BLUE];
screen.Clear(bgColour);
}
void FileBrowser::ShowDeviceAndROM()
{
char buffer[256];
u32 textColour = RGBA(0, 0, 0, 0xff);
u32 bgColour = RGBA(0xff, 0xff, 0xff, 0xff);
u32 y = STATUS_BAR_POSITION_Y;
snprintf(buffer, 256, "Device %d %s \r\n", deviceID, roms->ROMNames[roms->currentROMIndex]);
screen.PrintText(false, 43 * 8, y, buffer, textColour, bgColour);
}
void FileBrowser::DisplayDiskInfo(DiskImage* diskImage, const char* filenameForIcon)
{
// Ideally we should not have to load the entire disk to read the directory.
static const char* fileTypes[]=
{
"DEL", "SEQ", "PRG", "USR", "REL", "UKN", "UKN", "UKN"
};
// Decode the BAM
unsigned track = 18;
unsigned sectorNo = 0;
char name[17] = { 0 };
unsigned char buffer[260] = { 0 };
int charIndex;
u32 fontHeight = screen.GetCBMFontHeight();
u32 x = 0;
u32 y = 0;
char bufferOut[128] = { 0 };
u32 textColour = palette[VIC2_COLOUR_INDEX_LBLUE];
u32 bgColour = palette[VIC2_COLOUR_INDEX_BLUE];
u32 usedColour = palette[VIC2_COLOUR_INDEX_RED];
u32 freeColour = palette[VIC2_COLOUR_INDEX_LGREEN];
ClearScreen();
if (diskImage->GetDecodedSector(track, sectorNo, buffer))
{
track = buffer[0];
sectorNo = buffer[1];
//144-161 ($90-Al) Name of the disk (padded with "shift space")
//162,163 ($A2,$A3) Disk ID marker
//164 ($A4) $A0 Shift Space
//165,166 ($A5,$A6) $32,$41 ASCII chars "2A" DOS indicator
//167-170 ($A7-$AA) $A0 Shift Space
//171-255 ($AB-$FF) $00 Not used, filled with zero (The bytes 180 to 191 can have the contents "blocks free" on many disks.)
strncpy(name, (char*)&buffer[144], 16);
int blocksFree = 0;
int bamTrack;
int lastTrackUsed = (int)diskImage->LastTrackUsed() >> 1;
for (bamTrack = 0; bamTrack < 35; ++bamTrack)
{
if ((bamTrack + 1) != 18)
blocksFree += buffer[BAM_OFFSET + bamTrack * BAM_ENTRY_SIZE];
x = 400;
for (int bit = 0; bit < DiskImage::SectorsPerTrack[bamTrack]; bit++)
{
u32 bits = buffer[BAM_OFFSET + 1 + (bit >> 3) + bamTrack * BAM_ENTRY_SIZE];
bool used = (bits & (1 << (bit & 0x7))) == 0;
if (!used)
{
snprintf(bufferOut, 128, "%c", screen2petscii(87));
screen.PrintText(true, x, y, bufferOut, usedColour, bgColour);
}
else
{
snprintf(bufferOut, 128, "%c", screen2petscii(81));
screen.PrintText(true, x, y, bufferOut, freeColour, bgColour);
}
x += 8;
bits <<= 1;
}
y += fontHeight;
}
for (; bamTrack < lastTrackUsed; ++bamTrack)
{
x = 400;
for (int bit = 0; bit < DiskImage::SectorsPerTrack[bamTrack]; bit++)
{
snprintf(bufferOut, 128, "%c", screen2petscii(87));
screen.PrintText(true, x, y, bufferOut, usedColour, bgColour);
x += 8;
}
y += fontHeight;
}
x = 0;
y = 0;
snprintf(bufferOut, 128, "0");
screen.PrintText(true, x, y, bufferOut, textColour, bgColour);
x = 16;
snprintf(bufferOut, 128, "\"%s\" %c%c%c%c%c%c", name, buffer[162], buffer[163], buffer[164], buffer[165], buffer[166], buffer[167]);
screen.PrintText(true, x, y, bufferOut, bgColour, textColour);
x = 0;
y += fontHeight;
if (track != 0)
{
bool complete = false;
// Blocks 1 through 19 on track 18 contain the file entries. The first two bytes of a block point to the next directory block with file entries. If no more directory blocks follow, these bytes contain $00 and $FF, respectively.
while (!complete)
{
//DEBUG_LOG("track %d sector %d\r\n", track, sectorNo);
if (diskImage->GetDecodedSector(track, sectorNo, buffer))
{
unsigned trackNext = buffer[0];
unsigned sectorNoNext = buffer[1];
complete = (track == trackNext) && (sectorNo == sectorNoNext); // Detect looping directory entries (raid over moscow ntsc)
complete |= (trackNext == 00) || (sectorNoNext == 0xff);
complete |= (trackNext == 18) && (sectorNoNext == 1);
track = trackNext;
sectorNo = sectorNoNext;
int entry;
int entryOffset = 2;
for (entry = 0; entry < 8; ++entry)
{
bool done = true;
for (int i = 0; i < 0x1d; ++i)
{
if (buffer[i + entryOffset])
done = false;
}
if (!done)
{
u8 fileType = buffer[DIR_ENTRY_OFFSET_TYPE + entryOffset];
u16 blocks = (buffer[DIR_ENTRY_OFFSET_BLOCKS + entryOffset + 1] << 8) | buffer[DIR_ENTRY_OFFSET_BLOCKS + entryOffset];
x = 0;
for (charIndex = 0; charIndex < DIR_ENTRY_NAME_LENGTH; ++charIndex)
{
char c = buffer[DIR_ENTRY_OFFSET_NAME + entryOffset + charIndex];
if (c == 0xa0) c = 0x20;
name[charIndex] = c;
}
name[charIndex] = 0;
//DEBUG_LOG("%d name = %s %x\r\n", blocks, name, fileType);
snprintf(bufferOut, 128, "%d", blocks);
screen.PrintText(true, x, y, bufferOut, textColour, bgColour);
x += 5 * 8;
snprintf(bufferOut, 128, "\"%s\"", name);
screen.PrintText(true, x, y, bufferOut, textColour, bgColour);
x += 19 * 8;
char modifier = 0x20;
if ((fileType & 0x80) == 0)
modifier = screen2petscii(42);
else if (fileType & 0x40)
modifier = screen2petscii(60);
snprintf(bufferOut, 128, "%s%c", fileTypes[fileType & 7], modifier);
screen.PrintText(true, x, y, bufferOut, textColour, bgColour);
y += fontHeight;
}
entryOffset += 32;
}
}
else
{
// Error, just abort
complete = true;
}
}
}
x = 0;
//DEBUG_LOG("%d blocks free\r\n", blocksFree);
snprintf(bufferOut, 128, "%d BLOCKS FREE.\r\n", blocksFree);
screen.PrintText(true, x, y, bufferOut, textColour, bgColour);
y += fontHeight;
}
DisplayStatusBar();
if (filenameForIcon)
{
FILINFO filIcon;
if (CheckForPNG(filenameForIcon, filIcon))
DisplayPNG(filIcon, 1024 - 320, 0);
}
}
void FileBrowser::AutoSelectTestImage()
{
FileBrowser::BrowsableList::Entry* current = 0;
int index;
int maxEntries = folder.entries.size();
for (index = 0; index < maxEntries; ++index)
{
current = &folder.entries[index];
if (strcmp(current->filImage.fname, "someimage.g64") == 0)
{
break;
}
}
if (index != maxEntries)
{
caddySelections.Clear();
caddySelections.entries.push_back(*current);
selectionsMade = FillCaddyWithSelections();
}
}
Reference in New Issue View Git Blame Copy Permalink