archive/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2024-09-22 04:11:46 +02:00
Code Issues Projects Releases Packages Wiki Activity
dolphin/Source/Core/DolphinWX/MemcardManager.cpp
JosJuice 0f1ce0e1f4 Remove incorrect usage of "ASCII" and "ANSI" 
Windows-1252 was sometimes being referred to as ASCII or ANSI
in Dolphin, which is incorrect. ASCII is only a subset of
Windows-1252, and ANSI is (rather improperly) used in Windows
to refer to the current code page (which often is 1252 on
Western systems, but can also be something entirely different).

The commit also replaces "SJIS" with "Shift JIS". "SJIS"
isn't misleading, but "Shift JIS" is more commonly used.
2016-12-26 15:49:39 +01:00

857 lines
28 KiB
C++
Raw Blame History

// Copyright 2008 Dolphin Emulator Project
// Licensed under GPLv2+
// Refer to the license.txt file included.
#include <algorithm>
#include <array>
#include <cstring>
#include <string>
#include <vector>
#include <wx/bitmap.h>
#include <wx/button.h>
#include <wx/dialog.h>
#include <wx/filedlg.h>
#include <wx/filepicker.h>
#include <wx/image.h>
#include <wx/imaglist.h>
#include <wx/listbase.h>
#include <wx/menu.h>
#include <wx/msgdlg.h>
#include <wx/sizer.h>
#include <wx/stattext.h>
#include "Common/CommonTypes.h"
#include "Common/FileUtil.h"
#include "Common/IniFile.h"
#include "Common/Logging/Log.h"
#include "Common/MsgHandler.h"
#include "Common/StringUtil.h"
#include "Core/HW/GCMemcard.h"
#include "DolphinWX/MemcardManager.h"
#include "DolphinWX/WxUtils.h"
#define FIRSTPAGE 0
#define ARROWS slot ? "" : ARROW[slot], slot ? ARROW[slot] : ""
static wxImage wxImageFromMemoryRGBA(const u32* data, u32 width, u32 height)
{
wxImage image(width, height, false);
image.InitAlpha();
u8* rgb = image.GetData();
u8* alpha = image.GetAlpha();
for (u32 y = 0; y < height; ++y)
{
for (u32 x = 0; x < width; ++x)
{
u32 pixel = data[y * width + x];
*rgb++ = (pixel & 0x00FF0000) >> 16; // Red
*rgb++ = (pixel & 0x0000FF00) >> 8; // Green
*rgb++ = (pixel & 0x000000FF) >> 0; // Blue
*alpha++ = (pixel & 0xFF000000) >> 24;
}
}
return image;
}
BEGIN_EVENT_TABLE(CMemcardManager, wxDialog)
EVT_BUTTON(ID_COPYFROM_A, CMemcardManager::CopyDeleteClick)
EVT_BUTTON(ID_COPYFROM_B, CMemcardManager::CopyDeleteClick)
EVT_BUTTON(ID_DELETE_A, CMemcardManager::CopyDeleteClick)
EVT_BUTTON(ID_DELETE_B, CMemcardManager::CopyDeleteClick)
EVT_BUTTON(ID_SAVEIMPORT_B, CMemcardManager::CopyDeleteClick)
EVT_BUTTON(ID_SAVEEXPORT_B, CMemcardManager::CopyDeleteClick)
EVT_BUTTON(ID_SAVEIMPORT_A, CMemcardManager::CopyDeleteClick)
EVT_BUTTON(ID_SAVEEXPORT_A, CMemcardManager::CopyDeleteClick)
EVT_BUTTON(ID_CONVERTTOGCI, CMemcardManager::CopyDeleteClick)
EVT_BUTTON(ID_PREVPAGE_A, CMemcardManager::OnPageChange)
EVT_BUTTON(ID_NEXTPAGE_A, CMemcardManager::OnPageChange)
EVT_BUTTON(ID_PREVPAGE_B, CMemcardManager::OnPageChange)
EVT_BUTTON(ID_NEXTPAGE_B, CMemcardManager::OnPageChange)
EVT_FILEPICKER_CHANGED(ID_MEMCARDPATH_A, CMemcardManager::OnPathChange)
EVT_FILEPICKER_CHANGED(ID_MEMCARDPATH_B, CMemcardManager::OnPathChange)
EVT_MENU_RANGE(ID_MEMCARDPATH_A, ID_USEPAGES, CMemcardManager::OnMenuChange)
EVT_MENU_RANGE(ID_COPYFROM_A, ID_CONVERTTOGCI, CMemcardManager::CopyDeleteClick)
EVT_MENU_RANGE(ID_NEXTPAGE_A, ID_PREVPAGE_B, CMemcardManager::OnPageChange)
EVT_MENU_RANGE(COLUMN_BANNER, NUMBER_OF_COLUMN, CMemcardManager::OnMenuChange)
END_EVENT_TABLE()
CMemcardManager::CMemcardManager(wxWindow* parent)
: wxDialog(parent, wxID_ANY, _("Memory Card Manager"), wxDefaultPosition, wxDefaultSize,
wxCAPTION | wxSYSTEM_MENU | wxDIALOG_NO_PARENT | wxCLOSE_BOX | wxRESIZE_BORDER |
wxMAXIMIZE_BOX),
m_image_list_size(FromDIP(wxSize(96, 32)))
{
memoryCard[SLOT_A] = nullptr;
memoryCard[SLOT_B] = nullptr;
mcmSettings.twoCardsLoaded = false;
if (!LoadSettings())
{
itemsPerPage = 16;
mcmSettings.usePages = true;
for (int i = COLUMN_BANNER; i < NUMBER_OF_COLUMN; i++)
{
mcmSettings.column[i] = (i <= COLUMN_FIRSTBLOCK) ? true : false;
}
}
maxPages = (128 / itemsPerPage) - 1;
CreateGUIControls();
}
CMemcardManager::~CMemcardManager()
{
if (memoryCard[SLOT_A])
{
delete memoryCard[SLOT_A];
memoryCard[SLOT_A] = nullptr;
}
if (memoryCard[SLOT_B])
{
delete memoryCard[SLOT_B];
memoryCard[SLOT_B] = nullptr;
}
SaveSettings();
}
bool CMemcardManager::LoadSettings()
{
if (MemcardManagerIni.Load(File::GetUserPath(F_DOLPHINCONFIG_IDX)))
{
iniMemcardSection = MemcardManagerIni.GetOrCreateSection("MemcardManager");
iniMemcardSection->Get("Items per page", &itemsPerPage, 16);
iniMemcardSection->Get("DefaultMemcardA", &(DefaultMemcard[SLOT_A]), "");
iniMemcardSection->Get("DefaultMemcardB", &(DefaultMemcard[SLOT_B]), "");
iniMemcardSection->Get("DefaultIOFolder", &DefaultIOPath, "/Users/GC");
iniMemcardSection->Get("Use Pages", &mcmSettings.usePages, true);
iniMemcardSection->Get("cBanner", &mcmSettings.column[COLUMN_BANNER], true);
iniMemcardSection->Get("cTitle", &mcmSettings.column[COLUMN_TITLE], true);
iniMemcardSection->Get("cComment", &mcmSettings.column[COLUMN_COMMENT], true);
iniMemcardSection->Get("cIcon", &mcmSettings.column[COLUMN_ICON], true);
iniMemcardSection->Get("cBlocks", &mcmSettings.column[COLUMN_BLOCKS], true);
iniMemcardSection->Get("cFirst Block", &mcmSettings.column[COLUMN_FIRSTBLOCK], true);
mcmSettings.column[NUMBER_OF_COLUMN] = false;
for (int i = COLUMN_GAMECODE; i < NUMBER_OF_COLUMN; i++)
{
mcmSettings.column[i] = mcmSettings.column[NUMBER_OF_COLUMN];
}
return true;
}
return false;
}
bool CMemcardManager::SaveSettings()
{
MemcardManagerIni.Load(File::GetUserPath(F_DOLPHINCONFIG_IDX));
iniMemcardSection = MemcardManagerIni.GetOrCreateSection("MemcardManager");
iniMemcardSection->Set("Items per page", itemsPerPage, 16);
iniMemcardSection->Set("DefaultMemcardA", DefaultMemcard[SLOT_A], "");
iniMemcardSection->Set("DefaultMemcardB", DefaultMemcard[SLOT_B], "");
iniMemcardSection->Set("Use Pages", mcmSettings.usePages, true);
iniMemcardSection->Set("cBanner", mcmSettings.column[COLUMN_BANNER], true);
iniMemcardSection->Set("cTitle", mcmSettings.column[COLUMN_TITLE], true);
iniMemcardSection->Set("cComment", mcmSettings.column[COLUMN_COMMENT], true);
iniMemcardSection->Set("cIcon", mcmSettings.column[COLUMN_ICON], true);
iniMemcardSection->Set("cBlocks", mcmSettings.column[COLUMN_BLOCKS], true);
iniMemcardSection->Set("cFirst Block", mcmSettings.column[COLUMN_FIRSTBLOCK], true);
return MemcardManagerIni.Save(File::GetUserPath(F_DOLPHINCONFIG_IDX));
}
void CMemcardManager::CreateGUIControls()
{
// Create the controls for both memcards
const int space5 = FromDIP(5);
const char* ARROW[2] = {"<-", "->"};
m_ConvertToGci = new wxButton(this, ID_CONVERTTOGCI, _("Convert to GCI"));
wxStaticBoxSizer* sMemcard[2];
for (int slot = SLOT_A; slot <= SLOT_B; slot++)
{
m_CopyFrom[slot] = new wxButton(this, ID_COPYFROM_A + slot,
wxString::Format(_("%1$sCopy%1$s"), ARROW[slot ? 0 : 1]));
m_SaveImport[slot] =
new wxButton(this, ID_SAVEIMPORT_A + slot, wxString::Format(_("%sImport GCI%s"), ARROWS));
m_SaveExport[slot] =
new wxButton(this, ID_SAVEEXPORT_A + slot, wxString::Format(_("%sExport GCI%s"), ARROWS));
m_Delete[slot] =
new wxButton(this, ID_DELETE_A + slot, wxString::Format(_("%sDelete%s"), ARROWS));
m_PrevPage[slot] = new wxButton(this, ID_PREVPAGE_A + slot, _("Prev Page"));
m_NextPage[slot] = new wxButton(this, ID_NEXTPAGE_A + slot, _("Next Page"));
t_Status[slot] = new wxStaticText(this, 0, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0,
wxEmptyString);
wxFlexGridSizer* const paging_sizer = new wxFlexGridSizer(3, wxSize(space5, space5));
paging_sizer->AddGrowableCol(1);
paging_sizer->Add(m_PrevPage[slot], 0, wxEXPAND);
paging_sizer->Add(t_Status[slot], 0, wxALIGN_CENTER);
paging_sizer->Add(m_NextPage[slot], 0, wxEXPAND);
m_MemcardPath[slot] = new wxFilePickerCtrl(
this, ID_MEMCARDPATH_A + slot, StrToWxStr(File::GetUserPath(D_GCUSER_IDX)),
_("Choose a memory card:"),
_("GameCube Memory Cards (*.raw,*.gcp)") + wxString("|*.raw;*.gcp"), wxDefaultPosition,
wxDefaultSize, wxFLP_USE_TEXTCTRL | wxFLP_OPEN);
m_MemcardList[slot] = new CMemcardListCtrl(
this, ID_MEMCARDLIST_A + slot, wxDefaultPosition, FromDIP(wxSize(350, 400)),
wxLC_REPORT | wxSUNKEN_BORDER | wxLC_ALIGN_LEFT | wxLC_SINGLE_SEL, mcmSettings);
m_MemcardList[slot]->AssignImageList(
new wxImageList(m_image_list_size.GetWidth(), m_image_list_size.GetHeight()),
wxIMAGE_LIST_SMALL);
sMemcard[slot] = new wxStaticBoxSizer(wxVERTICAL, this,
_("Memory Card") + wxString::Format(" %c", 'A' + slot));
sMemcard[slot]->AddSpacer(space5);
sMemcard[slot]->Add(m_MemcardPath[slot], 0, wxEXPAND | wxLEFT | wxRIGHT, space5);
sMemcard[slot]->AddSpacer(space5);
sMemcard[slot]->Add(m_MemcardList[slot], 1, wxEXPAND | wxLEFT | wxRIGHT, space5);
sMemcard[slot]->AddSpacer(space5);
sMemcard[slot]->Add(paging_sizer, 0, wxEXPAND | wxLEFT | wxRIGHT, space5);
sMemcard[slot]->AddSpacer(space5);
}
wxBoxSizer* const sButtons = new wxBoxSizer(wxVERTICAL);
sButtons->AddStretchSpacer(2);
sButtons->Add(m_CopyFrom[SLOT_B], 0, wxEXPAND);
sButtons->Add(m_CopyFrom[SLOT_A], 0, wxEXPAND);
sButtons->AddStretchSpacer();
sButtons->Add(m_SaveImport[SLOT_A], 0, wxEXPAND);
sButtons->Add(m_SaveExport[SLOT_A], 0, wxEXPAND);
sButtons->AddStretchSpacer();
sButtons->Add(m_ConvertToGci, 0, wxEXPAND);
sButtons->AddStretchSpacer();
sButtons->Add(m_SaveImport[SLOT_B], 0, wxEXPAND);
sButtons->Add(m_SaveExport[SLOT_B], 0, wxEXPAND);
sButtons->AddStretchSpacer();
sButtons->Add(m_Delete[SLOT_A], 0, wxEXPAND);
sButtons->Add(m_Delete[SLOT_B], 0, wxEXPAND);
sButtons->AddStretchSpacer();
sButtons->Add(new wxButton(this, wxID_OK, _("Close")), 0, wxEXPAND);
sButtons->AddStretchSpacer();
wxBoxSizer* const sMain = new wxBoxSizer(wxHORIZONTAL);
sMain->AddSpacer(space5);
sMain->Add(sMemcard[SLOT_A], 1, wxEXPAND | wxTOP | wxBOTTOM, space5);
sMain->AddSpacer(space5);
sMain->Add(sButtons, 0, wxEXPAND | wxTOP | wxBOTTOM, space5);
sMain->AddSpacer(space5);
sMain->Add(sMemcard[SLOT_B], 1, wxEXPAND | wxTOP | wxBOTTOM, space5);
sMain->AddSpacer(space5);
SetSizerAndFit(sMain);
Center();
for (int i = SLOT_A; i <= SLOT_B; i++)
{
m_PrevPage[i]->Disable();
m_NextPage[i]->Disable();
m_CopyFrom[i]->Disable();
m_SaveImport[i]->Disable();
m_SaveExport[i]->Disable();
m_Delete[i]->Disable();
if (DefaultMemcard[i].length())
{
m_MemcardPath[i]->SetPath(StrToWxStr(DefaultMemcard[i]));
ChangePath(i);
}
}
}
void CMemcardManager::OnPathChange(wxFileDirPickerEvent& event)
{
ChangePath(event.GetId() - ID_MEMCARDPATH_A);
}
void CMemcardManager::ChangePath(int slot)
{
int slot2 = (slot == SLOT_A) ? SLOT_B : SLOT_A;
page[slot] = FIRSTPAGE;
if (mcmSettings.usePages && m_PrevPage[slot]->IsEnabled())
{
m_PrevPage[slot]->Disable();
m_MemcardList[slot]->prevPage = false;
}
if (!m_MemcardPath[SLOT_A]->GetPath().CmpNoCase(m_MemcardPath[SLOT_B]->GetPath()))
{
if (m_MemcardPath[slot]->GetPath().length())
wxMessageBox(_("Memcard already opened"));
}
else
{
if (m_MemcardPath[slot]->GetPath().length() &&
ReloadMemcard(WxStrToStr(m_MemcardPath[slot]->GetPath()), slot))
{
if (memoryCard[slot2])
{
mcmSettings.twoCardsLoaded = true;
}
m_SaveImport[slot]->Enable();
m_SaveExport[slot]->Enable();
m_Delete[slot]->Enable();
}
else
{
if (memoryCard[slot])
{
delete memoryCard[slot];
memoryCard[slot] = nullptr;
}
mcmSettings.twoCardsLoaded = false;
m_MemcardPath[slot]->SetPath(wxEmptyString);
m_MemcardList[slot]->ClearAll();
t_Status[slot]->SetLabel(wxEmptyString);
m_SaveImport[slot]->Disable();
m_SaveExport[slot]->Disable();
m_Delete[slot]->Disable();
if (mcmSettings.usePages)
{
m_PrevPage[slot]->Disable();
m_NextPage[slot]->Disable();
}
}
}
m_CopyFrom[SLOT_A]->Enable(mcmSettings.twoCardsLoaded);
m_CopyFrom[SLOT_B]->Enable(mcmSettings.twoCardsLoaded);
}
void CMemcardManager::OnPageChange(wxCommandEvent& event)
{
int slot = SLOT_B;
switch (event.GetId())
{
case ID_NEXTPAGE_A:
slot = SLOT_A;
case ID_NEXTPAGE_B:
if (!m_PrevPage[slot]->IsEnabled())
{
m_PrevPage[slot]->Enable();
m_MemcardList[slot]->prevPage = true;
}
page[slot]++;
if (page[slot] == maxPages)
{
m_NextPage[slot]->Disable();
m_MemcardList[slot]->nextPage = false;
}
ReloadMemcard(WxStrToStr(m_MemcardPath[slot]->GetPath()), slot);
break;
case ID_PREVPAGE_A:
slot = SLOT_A;
case ID_PREVPAGE_B:
if (!m_NextPage[slot]->IsEnabled())
{
m_NextPage[slot]->Enable();
m_MemcardList[slot]->nextPage = true;
}
page[slot]--;
if (!page[slot])
{
m_PrevPage[slot]->Disable();
m_MemcardList[slot]->prevPage = false;
}
ReloadMemcard(WxStrToStr(m_MemcardPath[slot]->GetPath()), slot);
break;
}
}
void CMemcardManager::OnMenuChange(wxCommandEvent& event)
{
int _id = event.GetId();
switch (_id)
{
case ID_MEMCARDPATH_A:
case ID_MEMCARDPATH_B:
DefaultMemcard[_id - ID_MEMCARDPATH_A] =
WxStrToStr(m_MemcardPath[_id - ID_MEMCARDPATH_A]->GetPath());
return;
case ID_USEPAGES:
mcmSettings.usePages = !mcmSettings.usePages;
if (!mcmSettings.usePages)
{
m_PrevPage[SLOT_A]->Disable();
m_PrevPage[SLOT_B]->Disable();
m_NextPage[SLOT_A]->Disable();
m_NextPage[SLOT_B]->Disable();
m_MemcardList[SLOT_A]->prevPage = m_MemcardList[SLOT_B]->prevPage = false;
page[SLOT_A] = page[SLOT_B] = FIRSTPAGE;
}
break;
case NUMBER_OF_COLUMN:
for (int i = COLUMN_GAMECODE; i <= NUMBER_OF_COLUMN; i++)
{
mcmSettings.column[i] = !mcmSettings.column[i];
}
break;
default:
mcmSettings.column[_id] = !mcmSettings.column[_id];
break;
}
if (memoryCard[SLOT_A])
ReloadMemcard(WxStrToStr(m_MemcardPath[SLOT_A]->GetPath()), SLOT_A);
if (memoryCard[SLOT_B])
ReloadMemcard(WxStrToStr(m_MemcardPath[SLOT_B]->GetPath()), SLOT_B);
}
bool CMemcardManager::CopyDeleteSwitch(u32 error, int slot)
{
switch (error)
{
case GCS:
wxMessageBox(_("File converted to .gci"));
break;
case SUCCESS:
if (slot != -1)
{
memoryCard[slot]->FixChecksums();
if (!memoryCard[slot]->Save())
PanicAlertT("File write failed");
page[slot] = FIRSTPAGE;
ReloadMemcard(WxStrToStr(m_MemcardPath[slot]->GetPath()), slot);
}
break;
case NOMEMCARD:
WxUtils::ShowErrorDialog(_("File is not recognized as a memcard"));
break;
case OPENFAIL:
WxUtils::ShowErrorDialog(_("File could not be opened\nor does not have a valid extension"));
break;
case OUTOFBLOCKS:
if (slot == -1)
{
WxUtils::ShowErrorDialog(_("Unknown memory card error"));
break;
}
wxMessageBox(
wxString::Format(_("Only %d blocks available"), memoryCard[slot]->GetFreeBlocks()));
break;
case OUTOFDIRENTRIES:
WxUtils::ShowErrorDialog(_("No free directory index entries."));
break;
case LENGTHFAIL:
WxUtils::ShowErrorDialog(_("Imported file has invalid length."));
break;
case INVALIDFILESIZE:
WxUtils::ShowErrorDialog(_("The save you are trying to copy has an invalid file size."));
break;
case TITLEPRESENT:
WxUtils::ShowErrorDialog(_("Memcard already has a save for this title."));
break;
case SAVFAIL:
WxUtils::ShowErrorDialog(
_("Imported file has sav extension\nbut does not have a correct header."));
break;
case GCSFAIL:
WxUtils::ShowErrorDialog(
_("Imported file has gsc extension\nbut does not have a correct header."));
break;
case FAIL:
if (slot == -1)
{
WxUtils::ShowErrorDialog(_("Export failed"));
return false;
}
WxUtils::ShowErrorDialog(_("Invalid bat.map or dir entry."));
break;
case WRITEFAIL:
WxUtils::ShowErrorDialog(_("File write failed"));
break;
case DELETE_FAIL:
WxUtils::ShowErrorDialog(
_("Order of files in the File Directory do not match the block order\n"
"Right click and export all of the saves,\nand import the saves to a new memcard\n"));
break;
default:
WxUtils::ShowErrorDialog(_("Unknown memory card error"));
break;
}
SetFocus();
return true;
}
void CMemcardManager::CopyDeleteClick(wxCommandEvent& event)
{
int index_A = m_MemcardList[SLOT_A]->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
int index_B = m_MemcardList[SLOT_B]->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
int slot = SLOT_B;
int slot2 = SLOT_A;
std::string fileName2("");
if (index_A != wxNOT_FOUND && page[SLOT_A])
index_A += itemsPerPage * page[SLOT_A];
if (index_B != wxNOT_FOUND && page[SLOT_B])
index_B += itemsPerPage * page[SLOT_B];
int index = index_B;
switch (event.GetId())
{
case ID_COPYFROM_B:
slot = SLOT_A;
slot2 = SLOT_B;
case ID_COPYFROM_A:
index = slot2 ? index_B : index_A;
index = memoryCard[slot2]->GetFileIndex(index);
if ((index != wxNOT_FOUND))
{
CopyDeleteSwitch(memoryCard[slot]->CopyFrom(*memoryCard[slot2], index), slot);
}
break;
case ID_FIXCHECKSUM_A:
slot = SLOT_A;
case ID_FIXCHECKSUM_B:
if (memoryCard[slot]->FixChecksums() && memoryCard[slot]->Save())
{
wxMessageBox(_("The checksum was successfully fixed."));
}
else
{
WxUtils::ShowErrorDialog(_("File write failed"));
}
break;
case ID_CONVERTTOGCI:
fileName2 = "convert";
case ID_SAVEIMPORT_A:
slot = SLOT_A;
case ID_SAVEIMPORT_B:
{
wxString fileName = wxFileSelector(
_("Select a save file to import"),
(strcmp(DefaultIOPath.c_str(), "/Users/GC") == 0) ? StrToWxStr("") :
StrToWxStr(DefaultIOPath),
wxEmptyString, wxEmptyString,
_("GameCube Savegame files(*.gci;*.gcs;*.sav)") + wxString("|*.gci;*.gcs;*.sav|") +
_("Native GCI files(*.gci)") + wxString("|*.gci|") +
_("MadCatz Gameshark files(*.gcs)") + wxString("|*.gcs|") +
_("Datel MaxDrive/Pro files(*.sav)") + wxString("|*.sav"),
wxFD_OPEN | wxFD_FILE_MUST_EXIST, this);
if (!fileName.empty() && !fileName2.empty())
{
wxString temp2 = wxFileSelector(_("Save GCI as..."), wxEmptyString, wxEmptyString, ".gci",
_("GCI File(*.gci)") + wxString("|*.gci"),
wxFD_OVERWRITE_PROMPT | wxFD_SAVE, this);
if (temp2.empty())
break;
fileName2 = WxStrToStr(temp2);
}
if (fileName.length() > 0)
{
CopyDeleteSwitch(memoryCard[slot]->ImportGci(WxStrToStr(fileName), fileName2), slot);
}
}
break;
case ID_SAVEEXPORT_A:
slot = SLOT_A;
index = index_A;
case ID_SAVEEXPORT_B:
index = memoryCard[slot]->GetFileIndex(index);
if (index != wxNOT_FOUND)
{
std::string gciFilename;
if (!memoryCard[slot]->GCI_FileName(index, gciFilename))
{
wxMessageBox(_("Invalid index"), _("Error"));
return;
}
wxString fileName = wxFileSelector(
_("Export save as..."), StrToWxStr(DefaultIOPath), StrToWxStr(gciFilename), ".gci",
_("Native GCI files(*.gci)") + wxString("|*.gci|") + _("MadCatz Gameshark files(*.gcs)") +
wxString("|*.gcs|") + _("Datel MaxDrive/Pro files(*.sav)") + wxString("|*.sav"),
wxFD_OVERWRITE_PROMPT | wxFD_SAVE, this);
if (fileName.length() > 0)
{
if (!CopyDeleteSwitch(memoryCard[slot]->ExportGci(index, WxStrToStr(fileName), ""), -1))
{
File::Delete(WxStrToStr(fileName));
}
}
}
break;
case ID_EXPORTALL_A:
slot = SLOT_A;
case ID_EXPORTALL_B:
{
std::string path1, path2, mpath;
mpath = WxStrToStr(m_MemcardPath[slot]->GetPath());
SplitPath(mpath, &path1, &path2, nullptr);
path1 += path2;
File::CreateDir(path1);
int answer = wxMessageBox(
wxString::Format(
_("Warning: This will overwrite any existing saves that are in the folder:\n"
"%s\nand have the same name as a file on your memcard\nContinue?"),
path1.c_str()),
_("Warning"), wxYES_NO);
if (answer == wxYES)
{
for (int i = 0; i < DIRLEN; i++)
{
CopyDeleteSwitch(memoryCard[slot]->ExportGci(i, "", path1), -1);
}
}
break;
}
case ID_DELETE_A:
slot = SLOT_A;
index = index_A;
case ID_DELETE_B:
index = memoryCard[slot]->GetFileIndex(index);
if (index != wxNOT_FOUND)
{
CopyDeleteSwitch(memoryCard[slot]->RemoveFile(index), slot);
}
break;
}
}
bool CMemcardManager::ReloadMemcard(const std::string& fileName, int card)
{
if (memoryCard[card])
delete memoryCard[card];
// TODO: add error checking and animate icons
memoryCard[card] = new GCMemcard(fileName);
if (!memoryCard[card]->IsValid())
return false;
int j;
wxString wxTitle, wxComment, wxBlock, wxFirstBlock, wxLabel;
m_MemcardList[card]->Hide();
m_MemcardList[card]->ClearAll();
m_MemcardList[card]->InsertColumn(COLUMN_BANNER, _("Banner"));
m_MemcardList[card]->InsertColumn(COLUMN_TITLE, _("Title"));
m_MemcardList[card]->InsertColumn(COLUMN_COMMENT, _("Comment"));
m_MemcardList[card]->InsertColumn(COLUMN_ICON, _("Icon"));
m_MemcardList[card]->InsertColumn(COLUMN_BLOCKS, _("Blocks"));
m_MemcardList[card]->InsertColumn(COLUMN_FIRSTBLOCK, _("First Block"));
wxImageList* list = m_MemcardList[card]->GetImageList(wxIMAGE_LIST_SMALL);
list->RemoveAll();
u8 nFiles = memoryCard[card]->GetNumFiles();
std::vector<int> images(nFiles * 2);
static constexpr unsigned int BANNER_WIDTH = 96;
static constexpr unsigned int ANIM_FRAME_WIDTH = 32;
static constexpr unsigned int IMAGE_HEIGHT = 32;
static constexpr unsigned int ANIM_MAX_FRAMES = 8;
std::vector<u32> pxdata(BANNER_WIDTH * IMAGE_HEIGHT);
std::vector<u8> anim_delay(ANIM_MAX_FRAMES);
std::vector<u32> anim_data(ANIM_FRAME_WIDTH * IMAGE_HEIGHT * ANIM_MAX_FRAMES);
for (u8 i = 0; i < nFiles; i++)
{
u8 file_index = memoryCard[card]->GetFileIndex(i);
u32 num_frames =
memoryCard[card]->ReadAnimRGBA8(file_index, anim_data.data(), anim_delay.data());
// Decode Save File Animation
wxImage anim_img_strip;
if (num_frames > 0)
{
unsigned int frames = BANNER_WIDTH / ANIM_FRAME_WIDTH;
if (num_frames < frames)
{
frames = num_frames;
// Clear unused frame's pixels from the buffer.
std::fill(pxdata.begin(), pxdata.end(), 0);
}
for (unsigned int f = 0; f < frames; ++f)
{
for (unsigned int y = 0; y < IMAGE_HEIGHT; ++y)
{
for (unsigned int x = 0; x < ANIM_FRAME_WIDTH; ++x)
{
// NOTE: pxdata is stacked horizontal, anim_data is stacked vertical
pxdata[y * BANNER_WIDTH + f * ANIM_FRAME_WIDTH + x] =
anim_data[f * ANIM_FRAME_WIDTH * IMAGE_HEIGHT + y * IMAGE_HEIGHT + x];
}
}
}
anim_img_strip = wxImageFromMemoryRGBA(pxdata.data(), BANNER_WIDTH, IMAGE_HEIGHT);
}
else
{
// No Animation found, use an empty placeholder instead.
anim_img_strip.Create(BANNER_WIDTH, IMAGE_HEIGHT, false);
anim_img_strip.Clear(0xFF);
anim_img_strip.SetMaskColour(0xFF, 0xFF, 0xFF);
}
// Decode Banner if it exists
{
wxImage image;
if (memoryCard[card]->ReadBannerRGBA8(file_index, pxdata.data()))
{
image = wxImageFromMemoryRGBA(pxdata.data(), BANNER_WIDTH, IMAGE_HEIGHT);
}
else
{
// Use first frame of animation instead.
image = anim_img_strip.Size(wxSize(ANIM_FRAME_WIDTH, IMAGE_HEIGHT), wxPoint(0, 0));
}
images[i * 2] = list->Add(WxUtils::ScaleImageToBitmap(image, this, m_image_list_size));
}
images[i * 2 + 1] =
list->Add(WxUtils::ScaleImageToBitmap(anim_img_strip, this, m_image_list_size));
}
int pagesMax = (mcmSettings.usePages) ? (page[card] + 1) * itemsPerPage : 128;
for (j = page[card] * itemsPerPage; (j < nFiles) && (j < pagesMax); j++)
{
u16 blocks;
u16 firstblock;
u8 fileIndex = memoryCard[card]->GetFileIndex(j);
int index = m_MemcardList[card]->InsertItem(j, wxEmptyString);
m_MemcardList[card]->SetItem(index, COLUMN_BANNER, wxEmptyString);
std::string title = memoryCard[card]->GetSaveComment1(fileIndex);
std::string comment = memoryCard[card]->GetSaveComment2(fileIndex);
auto const string_decoder = memoryCard[card]->IsShiftJIS() ? SHIFTJISToUTF8 : CP1252ToUTF8;
wxTitle = StrToWxStr(string_decoder(title));
wxComment = StrToWxStr(string_decoder(comment));
m_MemcardList[card]->SetItem(index, COLUMN_TITLE, wxTitle);
m_MemcardList[card]->SetItem(index, COLUMN_COMMENT, wxComment);
blocks = memoryCard[card]->DEntry_BlockCount(fileIndex);
if (blocks == 0xFFFF)
blocks = 0;
wxBlock.Printf("%10d", blocks);
m_MemcardList[card]->SetItem(index, COLUMN_BLOCKS, wxBlock);
firstblock = memoryCard[card]->DEntry_FirstBlock(fileIndex);
// if (firstblock == 0xFFFF) firstblock = 3; // to make firstblock -1
wxFirstBlock.Printf("%15d", firstblock);
m_MemcardList[card]->SetItem(index, COLUMN_FIRSTBLOCK, wxFirstBlock);
m_MemcardList[card]->SetItem(index, COLUMN_ICON, wxEmptyString);
if (images[j] >= 0)
{
m_MemcardList[card]->SetItemImage(index, images[j * 2]);
m_MemcardList[card]->SetItemColumnImage(index, COLUMN_ICON, images[j * 2 + 1]);
}
}
if (mcmSettings.usePages)
{
if (nFiles <= itemsPerPage)
{
m_PrevPage[card]->Disable();
m_MemcardList[card]->prevPage = false;
}
if (j == nFiles)
{
m_NextPage[card]->Disable();
m_MemcardList[card]->nextPage = false;
}
else
{
m_NextPage[card]->Enable();
m_MemcardList[card]->nextPage = true;
}
}
// Automatic column width and then show the list
for (int i = COLUMN_BANNER; i <= COLUMN_FIRSTBLOCK; i++)
{
if (mcmSettings.column[i])
m_MemcardList[card]->SetColumnWidth(i, wxLIST_AUTOSIZE);
else
m_MemcardList[card]->SetColumnWidth(i, 0);
}
m_MemcardList[card]->Show();
wxLabel.Printf(_("%u Free Blocks; %u Free Dir Entries"), memoryCard[card]->GetFreeBlocks(),
DIRLEN - nFiles);
t_Status[card]->SetLabel(wxLabel);
// Done so text doesn't overlap the UI.
this->Fit();
return true;
}
void CMemcardManager::CMemcardListCtrl::OnRightClick(wxMouseEvent& event)
{
int flags;
long item = HitTest(event.GetPosition(), flags);
wxMenu popupMenu;
if (item != wxNOT_FOUND)
{
if (GetItemState(item, wxLIST_STATE_SELECTED) != wxLIST_STATE_SELECTED)
{
SetItemState(item, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
}
SetItemState(item, wxLIST_STATE_FOCUSED, wxLIST_STATE_FOCUSED);
int slot = GetId() - ID_MEMCARDLIST_A;
popupMenu.Append(ID_COPYFROM_A + slot, wxString::Format(_("Copy to Memcard %c"), 'B' - slot));
popupMenu.Append(ID_DELETE_A + slot, _("Delete Save"));
popupMenu.Append(ID_SAVEIMPORT_A + slot, _("Import Save"));
popupMenu.Append(ID_SAVEEXPORT_A + slot, _("Export Save"));
popupMenu.Append(ID_EXPORTALL_A + slot, _("Export all saves"));
popupMenu.FindItem(ID_COPYFROM_A + slot)->Enable(__mcmSettings.twoCardsLoaded);
popupMenu.AppendSeparator();
popupMenu.Append(ID_FIXCHECKSUM_A + slot, _("Fix Checksums"));
popupMenu.Append(ID_PREVPAGE_A + slot, _("Previous Page"));
popupMenu.Append(ID_NEXTPAGE_A + slot, _("Next Page"));
popupMenu.Append(ID_MEMCARDPATH_A + slot,
wxString::Format(_("Set as default Memcard %c"), 'A' + slot));
popupMenu.AppendCheckItem(ID_USEPAGES, _("Enable pages"));
popupMenu.FindItem(ID_PREVPAGE_A + slot)->Enable(prevPage && __mcmSettings.usePages);
popupMenu.FindItem(ID_NEXTPAGE_A + slot)->Enable(nextPage && __mcmSettings.usePages);
popupMenu.FindItem(ID_USEPAGES)->Check(__mcmSettings.usePages);
popupMenu.AppendSeparator();
// popupMenu->AppendCheckItem(COLUMN_BANNER, _("Show save banner"));
popupMenu.AppendCheckItem(COLUMN_TITLE, _("Show save title"));
popupMenu.AppendCheckItem(COLUMN_COMMENT, _("Show save comment"));
popupMenu.AppendCheckItem(COLUMN_ICON, _("Show save icon"));
popupMenu.AppendCheckItem(COLUMN_BLOCKS, _("Show save blocks"));
popupMenu.AppendCheckItem(COLUMN_FIRSTBLOCK, _("Show first block"));
// for (int i = COLUMN_BANNER; i <= COLUMN_FIRSTBLOCK; i++)
for (int i = COLUMN_TITLE; i <= COLUMN_FIRSTBLOCK; i++)
{
popupMenu.FindItem(i)->Check(__mcmSettings.column[i]);
}
}
PopupMenu(&popupMenu);
}
Reference in a new issue View git blame Copy permalink