mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2024-09-21 03:41:42 +02:00
d032c40a58
- In icon retrieving I removed the "format check" as it shouldn't really matter to have mixed icon formats. Also removed the "Time splitters hack" as there's no reason for it since we are only checking the last 3 bits and I'm pretty sure having bits 1 and 2 set is the same as having them unset. - Icon retrieving uses AnimSpeed as stop signal (every icon must have an speed set, the first speed that is 0 means there are no more icons) - Also, in icon retrieving I added support for "blank frames"(Luigi's Mansion and Pikmin that I know of). With this the base for icon animation is complete. - Fixed PSOIII savegame patch which was wrong before. Signed-off-by: LPFaint99 <lpfaint99@gmail.com>
836 lines
25 KiB
C++
836 lines
25 KiB
C++
// Copyright (C) 2003 Dolphin Project.
|
|
|
|
// This program 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, version 2.0.
|
|
|
|
// This program 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 2.0 for more details.
|
|
|
|
// A copy of the GPL 2.0 should have been included with the program.
|
|
// If not, see http://www.gnu.org/licenses/
|
|
|
|
// Official SVN repository and contact information can be found at
|
|
// http://code.google.com/p/dolphin-emu/
|
|
|
|
#include "MemcardManager.h"
|
|
#include "Common.h"
|
|
#include "wx/mstream.h"
|
|
|
|
#define ARROWS slot ? _T("") : ARROW[slot], slot ? ARROW[slot] : _T("")
|
|
|
|
const u8 hdr[] = {
|
|
0x42,0x4D,
|
|
0x38,0x30,0x00,0x00,
|
|
0x00,0x00,0x00,0x00,
|
|
0x36,0x00,0x00,0x00,
|
|
0x28,0x00,0x00,0x00,
|
|
0x20,0x00,0x00,0x00, //W
|
|
0x20,0x00,0x00,0x00, //H
|
|
0x01,0x00,
|
|
0x20,0x00,
|
|
0x00,0x00,0x00,0x00,
|
|
0x02,0x30,0x00,0x00, //data size
|
|
0x12,0x0B,0x00,0x00,
|
|
0x12,0x0B,0x00,0x00,
|
|
0x00,0x00,0x00,0x00,
|
|
0x00,0x00,0x00,0x00
|
|
};
|
|
|
|
wxBitmap wxBitmapFromMemoryRGBA(const unsigned char* data, int width, int height)
|
|
{
|
|
int stride = (4*width);
|
|
|
|
int bytes = (stride*height) + sizeof(hdr);
|
|
|
|
bytes = (bytes+3)&(~3);
|
|
|
|
u8 *pdata = new u8[bytes];
|
|
|
|
memset(pdata,0,bytes);
|
|
memcpy(pdata,hdr,sizeof(hdr));
|
|
|
|
u8 *pixelData = pdata + sizeof(hdr);
|
|
|
|
for (int y=0;y<height;y++)
|
|
{
|
|
memcpy(pixelData+y*stride,data+(height-y-1)*stride,stride);
|
|
}
|
|
|
|
*(int*)(pdata+18) = width;
|
|
*(int*)(pdata+22) = height;
|
|
*(u32*)(pdata+34) = bytes-sizeof(hdr);
|
|
|
|
wxMemoryInputStream is(pdata, bytes);
|
|
wxBitmap map(wxImage(is, wxBITMAP_TYPE_BMP, -1), -1);
|
|
|
|
delete [] pdata;
|
|
|
|
return map;
|
|
}
|
|
|
|
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, wxWindowID id, const wxString& title, const wxPoint& position, const wxSize& size, long style)
|
|
: wxDialog(parent, id, title, position, size, style)
|
|
{
|
|
memoryCard[SLOT_A]=NULL;
|
|
memoryCard[SLOT_B]=NULL;
|
|
|
|
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] = NULL;
|
|
}
|
|
if (memoryCard[SLOT_B])
|
|
{
|
|
delete memoryCard[SLOT_B];
|
|
memoryCard[SLOT_B] = NULL;
|
|
}
|
|
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 wxChar* ARROW[2] = {_T("<-"), _T("->")};
|
|
|
|
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);
|
|
|
|
wxBoxSizer * const sPages = new wxBoxSizer(wxHORIZONTAL);
|
|
sPages->Add(m_PrevPage[slot], 0, wxEXPAND|wxALL, 1);
|
|
sPages->Add(t_Status[slot],0, wxEXPAND|wxALL, 5);
|
|
sPages->Add(0, 0, 1, wxEXPAND|wxALL, 0);
|
|
sPages->Add(m_NextPage[slot], 0, wxEXPAND|wxALL, 1);
|
|
|
|
m_MemcardPath[slot] = new wxFilePickerCtrl(this, ID_MEMCARDPATH_A + slot,
|
|
wxString::From8BitData(File::GetUserPath(D_GCUSER_IDX).c_str()), _("Choose a memory card:"),
|
|
_("Gamecube Memory Cards (*.raw,*.gcp)") + wxString(wxT("|*.raw;*.gcp")), wxDefaultPosition, wxDefaultSize, wxFLP_USE_TEXTCTRL|wxFLP_OPEN);
|
|
|
|
m_MemcardList[slot] = new CMemcardListCtrl(this, ID_MEMCARDLIST_A + slot, wxDefaultPosition, wxSize(350,400),
|
|
wxLC_REPORT | wxSUNKEN_BORDER | wxLC_ALIGN_LEFT | wxLC_SINGLE_SEL, mcmSettings);
|
|
|
|
m_MemcardList[slot]->AssignImageList(new wxImageList(96,32),wxIMAGE_LIST_SMALL);
|
|
|
|
sMemcard[slot] = new wxStaticBoxSizer(wxVERTICAL, this, _("Memory Card") + wxString::Format(wxT(" %c"), 'A' + slot));
|
|
sMemcard[slot]->Add(m_MemcardPath[slot], 0, wxEXPAND|wxALL, 5);
|
|
sMemcard[slot]->Add(m_MemcardList[slot], 1, wxEXPAND|wxALL, 5);
|
|
sMemcard[slot]->Add(sPages, 0, wxEXPAND|wxALL, 1);
|
|
}
|
|
|
|
wxBoxSizer * const sButtons = new wxBoxSizer(wxVERTICAL);
|
|
sButtons->AddStretchSpacer(2);
|
|
sButtons->Add(m_CopyFrom[SLOT_B], 0, wxEXPAND, 5);
|
|
sButtons->Add(m_CopyFrom[SLOT_A], 0, wxEXPAND, 5);
|
|
sButtons->AddStretchSpacer(1);
|
|
sButtons->Add(m_SaveImport[SLOT_A], 0, wxEXPAND, 5);
|
|
sButtons->Add(m_SaveExport[SLOT_A], 0, wxEXPAND, 5);
|
|
sButtons->AddStretchSpacer(1);
|
|
sButtons->Add(m_ConvertToGci, 0, wxEXPAND, 5);
|
|
sButtons->AddStretchSpacer(1);
|
|
sButtons->Add(m_SaveImport[SLOT_B], 0, wxEXPAND, 5);
|
|
sButtons->Add(m_SaveExport[SLOT_B], 0, wxEXPAND, 5);
|
|
sButtons->AddStretchSpacer(1);
|
|
sButtons->Add(m_Delete[SLOT_A], 0, wxEXPAND, 5);
|
|
sButtons->Add(m_Delete[SLOT_B], 0, wxEXPAND, 5);
|
|
sButtons->AddStretchSpacer();
|
|
sButtons->Add(new wxButton(this, wxID_OK, _("Close")), 0, wxEXPAND, 5);
|
|
sButtons->AddStretchSpacer();
|
|
|
|
wxBoxSizer * const sMain = new wxBoxSizer(wxHORIZONTAL);
|
|
sMain->Add(sMemcard[SLOT_A], 1, wxEXPAND|wxALL, 5);
|
|
sMain->Add(sButtons, 0, wxEXPAND, 0);
|
|
sMain->Add(sMemcard[SLOT_B], 1, wxEXPAND|wxALL, 5);
|
|
|
|
SetSizerAndFit(sMain);
|
|
Center();
|
|
SetFocus();
|
|
|
|
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(wxString::From8BitData(DefaultMemcard[i].c_str()));
|
|
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())
|
|
PanicAlertT("Memcard already opened");
|
|
}
|
|
else
|
|
{
|
|
if (m_MemcardPath[slot]->GetPath().length() && ReloadMemcard(m_MemcardPath[slot]->GetPath().mb_str(), 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] = NULL;
|
|
}
|
|
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(m_MemcardPath[slot]->GetPath().mb_str(), 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(m_MemcardPath[slot]->GetPath().mb_str(), 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] = m_MemcardPath[_id - ID_MEMCARDPATH_A]->GetPath().mb_str();
|
|
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(m_MemcardPath[SLOT_A]->GetPath().mb_str(), SLOT_A);
|
|
if (memoryCard[SLOT_B]) ReloadMemcard(m_MemcardPath[SLOT_B]->GetPath().mb_str(), SLOT_B);
|
|
}
|
|
bool CMemcardManager::CopyDeleteSwitch(u32 error, int slot)
|
|
{
|
|
switch (error)
|
|
{
|
|
case GCS:
|
|
SuccessAlertT("File converted to .gci");
|
|
break;
|
|
case SUCCESS:
|
|
if (slot != -1)
|
|
{
|
|
memoryCard[slot]->FixChecksums();
|
|
if (!memoryCard[slot]->Save()) PanicAlert(E_SAVEFAILED);
|
|
page[slot] = FIRSTPAGE;
|
|
ReloadMemcard(m_MemcardPath[slot]->GetPath().mb_str(), slot);
|
|
}
|
|
break;
|
|
case NOMEMCARD:
|
|
PanicAlertT("File is not recognized as a memcard");
|
|
break;
|
|
case OPENFAIL:
|
|
PanicAlertT("File could not be opened\nor does not have a valid extension");
|
|
break;
|
|
case OUTOFBLOCKS:
|
|
if (slot == -1)
|
|
{
|
|
PanicAlert(E_UNK);
|
|
break;
|
|
}
|
|
PanicAlertT("Only %d blocks available", memoryCard[slot]->GetFreeBlocks());
|
|
break;
|
|
case OUTOFDIRENTRIES:
|
|
PanicAlertT("No free dir index entries");
|
|
break;
|
|
case LENGTHFAIL:
|
|
PanicAlertT("Imported file has invalid length");
|
|
break;
|
|
case INVALIDFILESIZE:
|
|
PanicAlertT("The save you are trying to copy has an invalid file size");
|
|
break;
|
|
case TITLEPRESENT:
|
|
PanicAlertT("Memcard already has a save for this title");
|
|
break;
|
|
case SAVFAIL:
|
|
PanicAlertT("Imported file has sav extension\nbut does not have a correct header");
|
|
break;
|
|
case GCSFAIL:
|
|
PanicAlertT("Imported file has gsc extension\nbut does not have a correct header");
|
|
break;
|
|
case FAIL:
|
|
if (slot == -1)
|
|
{
|
|
PanicAlertT("Export Failed");
|
|
return false;
|
|
}
|
|
PanicAlertT("Invalid bat.map or dir entry");
|
|
break;
|
|
case WRITEFAIL:
|
|
PanicAlert(E_SAVEFAILED);
|
|
break;
|
|
case DELETE_FAIL:
|
|
PanicAlertT("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 the saves to a new memcard\n");
|
|
break;
|
|
default:
|
|
PanicAlert(E_UNK);
|
|
break;
|
|
}
|
|
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())
|
|
{
|
|
SuccessAlertT("The checksum was successfully fixed");
|
|
}
|
|
else PanicAlert(E_SAVEFAILED);
|
|
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)
|
|
? wxString::FromAscii("")
|
|
: wxString::From8BitData(DefaultIOPath.c_str()),
|
|
wxEmptyString, wxEmptyString,
|
|
_("GameCube Savegame files(*.gci;*.gcs;*.sav)") + wxString(wxT("|*.gci;*.gcs;*.sav|")) +
|
|
_("Native GCI files(*.gci)") + wxString(wxT("|*.gci|")) +
|
|
_("MadCatz Gameshark files(*.gcs)") + wxString(wxT("|*.gcs|")) +
|
|
_("Datel MaxDrive/Pro files(*.sav)") + wxString(wxT("|*.sav")),
|
|
wxFD_OPEN | wxFD_FILE_MUST_EXIST);
|
|
if (!fileName.empty() && !fileName2.empty())
|
|
{
|
|
wxString temp2 = wxFileSelector(_("Save GCI as..."),
|
|
wxEmptyString, wxEmptyString, wxT(".gci"),
|
|
_("GCI File(*.gci)") + wxString(_T("|*.gci")),
|
|
wxFD_OVERWRITE_PROMPT|wxFD_SAVE);
|
|
if (temp2.empty()) break;
|
|
fileName2 = temp2.mb_str();
|
|
}
|
|
if (fileName.length() > 0)
|
|
{
|
|
CopyDeleteSwitch(memoryCard[slot]->ImportGci(fileName.mb_str(), 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))
|
|
{
|
|
PanicAlert("invalid index");
|
|
return;
|
|
}
|
|
wxString fileName = wxFileSelector(
|
|
_("Export save as..."),
|
|
wxString::From8BitData(DefaultIOPath.c_str()),
|
|
wxString::From8BitData(gciFilename.c_str()), wxT(".gci"),
|
|
_("Native GCI files(*.gci)") + wxString(wxT("|*.gci|")) +
|
|
_("MadCatz Gameshark files(*.gcs)") + wxString(wxT("|*.gcs|")) +
|
|
_("Datel MaxDrive/Pro files(*.sav)") + wxString(wxT("|*.sav")),
|
|
wxFD_OVERWRITE_PROMPT|wxFD_SAVE);
|
|
|
|
if (fileName.length() > 0)
|
|
{
|
|
if (!CopyDeleteSwitch(memoryCard[slot]->ExportGci(index, fileName.mb_str(), ""), -1))
|
|
{
|
|
File::Delete(std::string(fileName.mb_str()));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case ID_EXPORTALL_A:
|
|
slot=SLOT_A;
|
|
case ID_EXPORTALL_B:
|
|
{
|
|
std::string path1, path2, mpath;
|
|
mpath = m_MemcardPath[slot]->GetPath().mb_str();
|
|
SplitPath(mpath, &path1, &path2, NULL);
|
|
path1 += path2;
|
|
File::CreateDir(path1);
|
|
if(PanicYesNoT("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()))
|
|
for (int i = 0; i < DIRLEN; i++)
|
|
{
|
|
CopyDeleteSwitch(memoryCard[slot]->ExportGci(i, NULL, 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 char *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();
|
|
int *images = new int[nFiles*2];
|
|
|
|
for (u8 i = 0;i < nFiles;i++)
|
|
{
|
|
static u32 pxdata[96*32];
|
|
static u8 animDelay[8];
|
|
static u32 animData[32*32*8];
|
|
|
|
u8 fileIndex = memoryCard[card]->GetFileIndex(i);
|
|
int numFrames = memoryCard[card]->ReadAnimRGBA8(fileIndex, animData, animDelay);
|
|
|
|
if (!memoryCard[card]->ReadBannerRGBA8(fileIndex, pxdata))
|
|
{
|
|
memset(pxdata,0,96*32*4);
|
|
|
|
if (numFrames>0) // Just use the first one
|
|
{
|
|
u32 *icdata = animData;
|
|
|
|
for (int y=0;y<32;y++)
|
|
{
|
|
for (int x=0;x<32;x++)
|
|
{
|
|
pxdata[y*96+x+32] = icdata[y*32+x];// | 0xFF000000
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
wxBitmap map = wxBitmapFromMemoryRGBA((u8*)pxdata,96,32);
|
|
images[i*2] = list->Add(map);
|
|
|
|
if (numFrames>0)
|
|
{
|
|
memset(pxdata,0,96*32*4);
|
|
int frames=3;
|
|
if (numFrames<frames) frames=numFrames;
|
|
for (int f=0;f<frames;f++)
|
|
{
|
|
for (int y=0;y<32;y++)
|
|
{
|
|
for (int x=0;x<32;x++)
|
|
{
|
|
pxdata[y*96 + x + 32*f] = animData[f*32*32 + y*32 + x];
|
|
}
|
|
}
|
|
}
|
|
wxBitmap icon = wxBitmapFromMemoryRGBA((u8*)pxdata,96,32);
|
|
images[i*2+1] = list->Add(icon);
|
|
}
|
|
}
|
|
|
|
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);
|
|
|
|
bool ascii = memoryCard[card]->IsAsciiEncoding();
|
|
|
|
#ifdef _WIN32
|
|
wxCSConv SJISConv(*(wxCSConv*)wxConvCurrent);
|
|
static bool validCP932 = ::IsValidCodePage(932) != 0;
|
|
if (validCP932)
|
|
{
|
|
SJISConv = wxCSConv(wxFontMapper::GetEncodingName(wxFONTENCODING_SHIFT_JIS));
|
|
}
|
|
else
|
|
{
|
|
WARN_LOG(COMMON, "Cannot Convert from Charset Windows Japanese cp 932");
|
|
}
|
|
#else
|
|
// on linux the wrong string is returned from wxFontMapper::GetEncodingName(wxFONTENCODING_SHIFT_JIS)
|
|
// it returns CP-932, in order to use iconv we need to use CP932
|
|
wxCSConv SJISConv(wxT("CP932"));
|
|
#endif
|
|
wxTitle = wxString(title.c_str(), ascii ? *wxConvCurrent : SJISConv);
|
|
wxComment = wxString(comment.c_str(), ascii ? *wxConvCurrent : SJISConv);
|
|
|
|
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(wxT("%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(wxT("%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;
|
|
}
|
|
}
|
|
|
|
delete[] images;
|
|
// 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);
|
|
|
|
return true;
|
|
}
|
|
|
|
void CMemcardManager::CMemcardListCtrl::OnRightClick(wxMouseEvent& event)
|
|
{
|
|
|
|
int flags;
|
|
long item = HitTest(event.GetPosition(), flags);
|
|
wxMenu* popupMenu = new wxMenu;
|
|
|
|
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);
|
|
}
|
|
|