DolphinWX: Separate the information panel from ISOProperties

Makes the information panel self-contained.

This was done first, as opposed to isolating the GameConfig panel--the
first panel in the group--as this panel had code all over the place in
ISOProperties, so I figured it'd be best to fix this one up first.
This commit is contained in:
Lioncash
2016-12-01 21:21:46 -05:00
parent 0705c53681
commit 20fcfd0ed8
9 changed files with 526 additions and 348 deletions
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,203 @@
// Copyright 2008 Dolphin Emulator Project
// Licensed under GPLv2+
// Refer to the license.txt file included.
#pragma once
#include <cstddef>
#include <memory>
#include <set>
#include <string>
#include <utility>
#include <vector>
#include <wx/dialog.h>
#include <wx/treebase.h>
#include "Common/IniFile.h"
#include "DiscIO/Filesystem.h"
#include "DiscIO/Volume.h"
#include "DolphinWX/ISOFile.h"
#include "DolphinWX/PatchAddEdit.h"
class DolphinSlider;
class wxButton;
class wxCheckBox;
class wxCheckListBox;
class wxChoice;
class wxSpinCtrl;
class wxStaticBitmap;
class wxTextCtrl;
class wxTreeCtrl;
namespace DiscIO
{
enum class Language;
}
namespace Gecko
{
class CodeConfigPanel;
}
class ActionReplayCodesPanel;
class CheatWarningMessage;
class GameListItem;
class WiiPartition final : public wxTreeItemData
{
public:
WiiPartition(std::unique_ptr<DiscIO::IVolume> partition,
std::unique_ptr<DiscIO::IFileSystem> file_system)
: Partition(std::move(partition)), FileSystem(std::move(file_system))
{
}
std::unique_ptr<DiscIO::IVolume> Partition;
std::unique_ptr<DiscIO::IFileSystem> FileSystem;
};
struct PHackData
{
bool PHackSZNear;
bool PHackSZFar;
std::string PHZNear;
std::string PHZFar;
};
wxDECLARE_EVENT(DOLPHIN_EVT_CHANGE_ISO_PROPERTIES_TITLE, wxCommandEvent);
class CISOProperties : public wxDialog
{
public:
CISOProperties(const GameListItem& game_list_item, wxWindow* parent, wxWindowID id = wxID_ANY,
const wxString& title = _("Properties"), const wxPoint& pos = wxDefaultPosition,
const wxSize& size = wxDefaultSize,
long style = wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER);
virtual ~CISOProperties();
private:
DECLARE_EVENT_TABLE();
std::unique_ptr<DiscIO::IVolume> m_open_iso;
std::unique_ptr<DiscIO::IFileSystem> m_filesystem;
std::vector<PatchEngine::Patch> onFrame;
PHackData m_PHack_Data;
// Core
wxCheckBox *CPUThread, *MMU, *DCBZOFF, *FPRF;
wxCheckBox *SyncGPU, *FastDiscSpeed, *DSPHLE;
wxArrayString arrayStringFor_GPUDeterminism;
wxChoice* GPUDeterminism;
// Wii
wxCheckBox* EnableWideScreen;
// Stereoscopy
DolphinSlider* DepthPercentage;
wxSpinCtrl* Convergence;
wxCheckBox* MonoDepth;
wxArrayString arrayStringFor_EmuState;
wxChoice* EmuState;
wxTextCtrl* EmuIssues;
wxCheckListBox* Patches;
wxButton* EditPatch;
wxButton* RemovePatch;
wxTreeCtrl* m_Treectrl;
wxTreeItemId RootId;
ActionReplayCodesPanel* m_ar_code_panel;
Gecko::CodeConfigPanel* m_geckocode_panel;
CheatWarningMessage* m_cheats_disabled_ar;
CheatWarningMessage* m_cheats_disabled_gecko;
enum
{
ID_TREECTRL = 1000,
ID_NOTEBOOK,
ID_GAMECONFIG,
ID_PATCH_PAGE,
ID_ARCODE_PAGE,
ID_SPEEDHACK_PAGE,
ID_INFORMATION,
ID_FILESYSTEM,
ID_USEDUALCORE,
ID_MMU,
ID_DCBZOFF,
ID_FPRF,
ID_SYNCGPU,
ID_DISCSPEED,
ID_AUDIO_DSP_HLE,
ID_USE_BBOX,
ID_ENABLEPROGRESSIVESCAN,
ID_ENABLEWIDESCREEN,
ID_EDITCONFIG,
ID_SHOWDEFAULTCONFIG,
ID_EMUSTATE,
ID_EMU_ISSUES,
ID_PATCHES_LIST,
ID_EDITPATCH,
ID_ADDPATCH,
ID_REMOVEPATCH,
ID_GPUDETERMINISM,
ID_DEPTHPERCENTAGE,
ID_CONVERGENCE,
ID_MONODEPTH,
IDM_EXTRACTDIR,
IDM_EXTRACTALL,
IDM_EXTRACTFILE,
IDM_EXTRACTAPPLOADER,
IDM_EXTRACTDOL,
IDM_CHECKINTEGRITY,
};
void LaunchExternalEditor(const std::string& filename, bool wait_until_closed);
void CreateGUIControls();
void OnClose(wxCloseEvent& event);
void OnCloseClick(wxCommandEvent& event);
void OnEditConfig(wxCommandEvent& event);
void OnShowDefaultConfig(wxCommandEvent& event);
void PatchListSelectionChanged(wxCommandEvent& event);
void PatchButtonClicked(wxCommandEvent& event);
void OnRightClickOnTree(wxTreeEvent& event);
void OnExtractFile(wxCommandEvent& event);
void OnExtractDir(wxCommandEvent& event);
void OnExtractDataFromHeader(wxCommandEvent& event);
void CheckPartitionIntegrity(wxCommandEvent& event);
void OnEmustateChanged(wxCommandEvent& event);
void OnCheatCodeToggled(wxCommandEvent& event);
void OnChangeTitle(wxCommandEvent& event);
const GameListItem OpenGameListItem;
size_t CreateDirectoryTree(wxTreeItemId& parent, const std::vector<DiscIO::SFileInfo>& fileInfos);
size_t CreateDirectoryTree(wxTreeItemId& parent, const std::vector<DiscIO::SFileInfo>& fileInfos,
const size_t _FirstIndex, const size_t _LastIndex);
void ExportDir(const std::string& _rFullPath, const std::string& _rExportFilename,
const WiiPartition* partition = nullptr);
IniFile GameIniDefault;
IniFile GameIniLocal;
std::string GameIniFileLocal;
std::string game_id;
std::set<std::string> DefaultPatches;
void LoadGameConfig();
bool SaveGameConfig();
void OnLocalIniModified(wxCommandEvent& ev);
void GenerateLocalIniModified();
void PatchList_Load();
void PatchList_Save();
long GetElementStyle(const char* section, const char* key);
void SetCheckboxValueFromGameini(const char* section, const char* key, wxCheckBox* checkbox);
void SaveGameIniValueFrom3StateCheckbox(const char* section, const char* key,
wxCheckBox* checkbox);
};
@@ -0,0 +1,402 @@
// Copyright 2016 Dolphin Emulator Project
// Licensed under GPLv2+
// Refer to the license.txt file included.
#include "DolphinWX/ISOProperties/InfoPanel.h"
#include <algorithm>
#include <iterator>
#include <string>
#include <vector>
#include <wx/arrstr.h>
#include <wx/bitmap.h>
#include <wx/button.h>
#include <wx/choice.h>
#include <wx/filedlg.h>
#include <wx/gbsizer.h>
#include <wx/menu.h>
#include <wx/progdlg.h>
#include <wx/sizer.h>
#include <wx/statbmp.h>
#include <wx/stattext.h>
#include <wx/textctrl.h>
#include <wx/utils.h>
#include "Common/MD5.h"
#include "Common/StringUtil.h"
#include "Core/ConfigManager.h"
#include "DiscIO/Enums.h"
#include "DiscIO/Volume.h"
#include "DolphinWX/ISOFile.h"
#include "DolphinWX/ISOProperties/ISOProperties.h"
#include "DolphinWX/WxUtils.h"
namespace
{
wxArrayString GetLanguageChoiceStrings(const std::vector<DiscIO::Language>& languages)
{
wxArrayString available_languages;
for (auto language : languages)
{
switch (language)
{
case DiscIO::Language::LANGUAGE_JAPANESE:
available_languages.Add(_("Japanese"));
break;
case DiscIO::Language::LANGUAGE_ENGLISH:
available_languages.Add(_("English"));
break;
case DiscIO::Language::LANGUAGE_GERMAN:
available_languages.Add(_("German"));
break;
case DiscIO::Language::LANGUAGE_FRENCH:
available_languages.Add(_("French"));
break;
case DiscIO::Language::LANGUAGE_SPANISH:
available_languages.Add(_("Spanish"));
break;
case DiscIO::Language::LANGUAGE_ITALIAN:
available_languages.Add(_("Italian"));
break;
case DiscIO::Language::LANGUAGE_DUTCH:
available_languages.Add(_("Dutch"));
break;
case DiscIO::Language::LANGUAGE_SIMPLIFIED_CHINESE:
available_languages.Add(_("Simplified Chinese"));
break;
case DiscIO::Language::LANGUAGE_TRADITIONAL_CHINESE:
available_languages.Add(_("Traditional Chinese"));
break;
case DiscIO::Language::LANGUAGE_KOREAN:
available_languages.Add(_("Korean"));
break;
case DiscIO::Language::LANGUAGE_UNKNOWN:
default:
available_languages.Add(_("Unknown"));
break;
}
}
return available_languages;
}
wxString GetCountryName(DiscIO::Country country)
{
switch (country)
{
case DiscIO::Country::COUNTRY_AUSTRALIA:
return _("Australia");
case DiscIO::Country::COUNTRY_EUROPE:
return _("Europe");
case DiscIO::Country::COUNTRY_FRANCE:
return _("France");
case DiscIO::Country::COUNTRY_ITALY:
return _("Italy");
case DiscIO::Country::COUNTRY_GERMANY:
return _("Germany");
case DiscIO::Country::COUNTRY_NETHERLANDS:
return _("Netherlands");
case DiscIO::Country::COUNTRY_RUSSIA:
return _("Russia");
case DiscIO::Country::COUNTRY_SPAIN:
return _("Spain");
case DiscIO::Country::COUNTRY_USA:
return _("USA");
case DiscIO::Country::COUNTRY_JAPAN:
return _("Japan");
case DiscIO::Country::COUNTRY_KOREA:
return _("Korea");
case DiscIO::Country::COUNTRY_TAIWAN:
return _("Taiwan");
case DiscIO::Country::COUNTRY_WORLD:
return _("World");
case DiscIO::Country::COUNTRY_UNKNOWN:
default:
return _("Unknown");
}
}
int FindPreferredLanguageIndex(DiscIO::Language preferred_language,
const std::vector<DiscIO::Language>& languages)
{
const auto iter =
std::find_if(languages.begin(), languages.end(),
[preferred_language](auto language) { return language == preferred_language; });
if (iter == languages.end())
return 0;
return static_cast<int>(std::distance(languages.begin(), iter));
}
} // Anonymous namespace
InfoPanel::InfoPanel(wxWindow* parent, wxWindowID id, const GameListItem& item,
const std::unique_ptr<DiscIO::IVolume>& opened_iso)
: wxPanel{parent, id}, m_game_list_item{item}, m_opened_iso{opened_iso}
{
CreateGUI();
BindEvents();
LoadGUIData();
}
void InfoPanel::CreateGUI()
{
const int space_5 = FromDIP(5);
auto* const main_sizer = new wxBoxSizer(wxVERTICAL);
main_sizer->AddSpacer(space_5);
main_sizer->Add(CreateISODetailsSizer(), 0, wxEXPAND | wxLEFT | wxRIGHT, space_5);
main_sizer->AddSpacer(space_5);
main_sizer->Add(CreateBannerDetailsSizer(), 0, wxEXPAND | wxLEFT | wxRIGHT, space_5);
main_sizer->AddSpacer(space_5);
SetSizer(main_sizer);
}
void InfoPanel::BindEvents()
{
m_md5_sum_compute->Bind(wxEVT_BUTTON, &InfoPanel::OnComputeMD5, this);
m_languages->Bind(wxEVT_CHOICE, &InfoPanel::OnChangeBannerLanguage, this);
Bind(wxEVT_MENU, &InfoPanel::OnSaveBannerImage, this, IDM_SAVE_BANNER);
}
void InfoPanel::LoadGUIData()
{
LoadISODetails();
LoadBannerDetails();
}
void InfoPanel::LoadISODetails()
{
m_internal_name->SetValue(StrToWxStr(m_opened_iso->GetInternalName()));
m_game_id->SetValue(StrToWxStr(m_opened_iso->GetGameID()));
m_country->SetValue(GetCountryName(m_opened_iso->GetCountry()));
m_maker_id->SetValue("0x" + StrToWxStr(m_opened_iso->GetMakerID()));
m_revision->SetValue(StrToWxStr(std::to_string(m_opened_iso->GetRevision())));
m_date->SetValue(StrToWxStr(m_opened_iso->GetApploaderDate()));
m_fst->SetValue(StrToWxStr(std::to_string(m_opened_iso->GetFSTSize())));
}
void InfoPanel::LoadBannerDetails()
{
LoadBannerImage();
const bool is_wii = m_opened_iso->GetVolumeType() != DiscIO::Platform::GAMECUBE_DISC;
ChangeBannerDetails(SConfig::GetInstance().GetCurrentLanguage(is_wii));
}
void InfoPanel::LoadBannerImage()
{
const auto& banner_image = m_game_list_item.GetBannerImage();
const auto banner_min_size = m_banner->GetMinSize();
if (banner_image.IsOk())
{
m_banner->SetBitmap(WxUtils::ScaleImageToBitmap(banner_image, this, banner_min_size));
m_banner->Bind(wxEVT_RIGHT_DOWN, &InfoPanel::OnRightClickBanner, this);
}
else
{
m_banner->SetBitmap(WxUtils::LoadScaledResourceBitmap("nobanner", this, banner_min_size));
}
}
wxStaticBoxSizer* InfoPanel::CreateISODetailsSizer()
{
auto* const internal_name_text = new wxStaticText(this, wxID_ANY, _("Internal Name:"));
m_internal_name =
new wxTextCtrl(this, ID_NAME, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY);
auto* const game_id_text = new wxStaticText(this, wxID_ANY, _("Game ID:"));
m_game_id = new wxTextCtrl(this, ID_GAME_ID, wxEmptyString, wxDefaultPosition, wxDefaultSize,
wxTE_READONLY);
auto* const country_text = new wxStaticText(this, wxID_ANY, _("Country:"));
m_country = new wxTextCtrl(this, ID_COUNTRY, wxEmptyString, wxDefaultPosition, wxDefaultSize,
wxTE_READONLY);
auto* const maker_id_text = new wxStaticText(this, wxID_ANY, _("Maker ID:"));
m_maker_id = new wxTextCtrl(this, ID_MAKER_ID, wxEmptyString, wxDefaultPosition, wxDefaultSize,
wxTE_READONLY);
auto* const revision_text = new wxStaticText(this, wxID_ANY, _("Revision:"));
m_revision = new wxTextCtrl(this, ID_REVISION, wxEmptyString, wxDefaultPosition, wxDefaultSize,
wxTE_READONLY);
auto* const date_text = new wxStaticText(this, wxID_ANY, _("Apploader Date:"));
m_date =
new wxTextCtrl(this, ID_DATE, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY);
auto* const fst_text = new wxStaticText(this, wxID_ANY, _("FST Size:"));
m_fst =
new wxTextCtrl(this, ID_FST, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_READONLY);
auto* const md5_sum_text = new wxStaticText(this, wxID_ANY, _("MD5 Checksum:"));
m_md5_sum = new wxTextCtrl(this, ID_MD5_SUM, wxEmptyString, wxDefaultPosition, wxDefaultSize,
wxTE_READONLY);
m_md5_sum_compute = new wxButton(this, ID_MD5_SUM_COMPUTE, _("Compute"));
const int space_10 = FromDIP(10);
auto* const iso_details = new wxGridBagSizer(space_10, space_10);
iso_details->Add(internal_name_text, wxGBPosition(0, 0), wxGBSpan(1, 1), wxALIGN_CENTER_VERTICAL);
iso_details->Add(m_internal_name, wxGBPosition(0, 1), wxGBSpan(1, 2), wxEXPAND);
iso_details->Add(game_id_text, wxGBPosition(1, 0), wxGBSpan(1, 1), wxALIGN_CENTER_VERTICAL);
iso_details->Add(m_game_id, wxGBPosition(1, 1), wxGBSpan(1, 2), wxEXPAND);
iso_details->Add(country_text, wxGBPosition(2, 0), wxGBSpan(1, 1), wxALIGN_CENTER_VERTICAL);
iso_details->Add(m_country, wxGBPosition(2, 1), wxGBSpan(1, 2), wxEXPAND);
iso_details->Add(maker_id_text, wxGBPosition(3, 0), wxGBSpan(1, 1), wxALIGN_CENTER_VERTICAL);
iso_details->Add(m_maker_id, wxGBPosition(3, 1), wxGBSpan(1, 2), wxEXPAND);
iso_details->Add(revision_text, wxGBPosition(4, 0), wxGBSpan(1, 1), wxALIGN_CENTER_VERTICAL);
iso_details->Add(m_revision, wxGBPosition(4, 1), wxGBSpan(1, 2), wxEXPAND);
iso_details->Add(date_text, wxGBPosition(5, 0), wxGBSpan(1, 1), wxALIGN_CENTER_VERTICAL);
iso_details->Add(m_date, wxGBPosition(5, 1), wxGBSpan(1, 2), wxEXPAND);
iso_details->Add(fst_text, wxGBPosition(6, 0), wxGBSpan(1, 1), wxALIGN_CENTER_VERTICAL);
iso_details->Add(m_fst, wxGBPosition(6, 1), wxGBSpan(1, 2), wxEXPAND);
iso_details->Add(md5_sum_text, wxGBPosition(7, 0), wxGBSpan(1, 1), wxALIGN_CENTER_VERTICAL);
iso_details->Add(m_md5_sum, wxGBPosition(7, 1), wxGBSpan(1, 1), wxEXPAND);
iso_details->Add(m_md5_sum_compute, wxGBPosition(7, 2), wxGBSpan(1, 1), wxEXPAND);
iso_details->AddGrowableCol(1);
const int space_5 = FromDIP(5);
auto* const iso_details_sizer = new wxStaticBoxSizer(wxVERTICAL, this, _("ISO Details"));
iso_details_sizer->AddSpacer(space_5);
iso_details_sizer->Add(iso_details, 0, wxEXPAND | wxLEFT | wxRIGHT, space_5);
iso_details_sizer->AddSpacer(space_5);
return iso_details_sizer;
}
wxStaticBoxSizer* InfoPanel::CreateBannerDetailsSizer()
{
auto* const name_text = new wxStaticText(this, wxID_ANY, _("Name:"));
m_name = new wxTextCtrl(this, ID_SHORT_NAME, wxEmptyString, wxDefaultPosition, wxDefaultSize,
wxTE_READONLY);
auto* const maker_text = new wxStaticText(this, wxID_ANY, _("Maker:"));
m_maker = new wxTextCtrl(this, ID_MAKER, wxEmptyString, wxDefaultPosition, wxDefaultSize,
wxTE_READONLY);
auto* const comment_text = new wxStaticText(this, wxID_ANY, _("Description:"));
m_comment = new wxTextCtrl(this, ID_COMMENT, wxEmptyString, wxDefaultPosition, wxDefaultSize,
wxTE_MULTILINE | wxTE_READONLY);
auto* const banner_text = new wxStaticText(this, wxID_ANY, _("Banner:"));
m_banner =
new wxStaticBitmap(this, ID_BANNER, wxNullBitmap, wxDefaultPosition, FromDIP(wxSize(96, 32)));
auto* const languages_text = new wxStaticText(this, wxID_ANY, _("Show Language:"));
m_languages = CreateCommentLanguageChoice();
const int space_10 = FromDIP(10);
auto* const banner_details = new wxGridBagSizer(space_10, space_10);
banner_details->Add(languages_text, wxGBPosition(0, 0), wxGBSpan(1, 1), wxALIGN_CENTER_VERTICAL);
// Comboboxes cannot be safely stretched vertically on Windows.
banner_details->Add(WxUtils::GiveMinSize(m_languages, wxDefaultSize), wxGBPosition(0, 1),
wxGBSpan(1, 1), wxEXPAND);
banner_details->Add(name_text, wxGBPosition(1, 0), wxGBSpan(1, 1), wxALIGN_CENTER_VERTICAL);
banner_details->Add(m_name, wxGBPosition(1, 1), wxGBSpan(1, 1), wxEXPAND);
banner_details->Add(maker_text, wxGBPosition(2, 0), wxGBSpan(1, 1), wxALIGN_CENTER_VERTICAL);
banner_details->Add(m_maker, wxGBPosition(2, 1), wxGBSpan(1, 1), wxEXPAND);
banner_details->Add(comment_text, wxGBPosition(3, 0), wxGBSpan(1, 1));
banner_details->Add(m_comment, wxGBPosition(3, 1), wxGBSpan(1, 1), wxEXPAND);
banner_details->Add(banner_text, wxGBPosition(4, 0), wxGBSpan(1, 1));
banner_details->Add(m_banner, wxGBPosition(4, 1), wxGBSpan(1, 1));
banner_details->AddGrowableCol(1);
const int space_5 = FromDIP(5);
auto* const banner_details_sizer = new wxStaticBoxSizer(wxVERTICAL, this, _("Banner Details"));
banner_details_sizer->AddSpacer(space_5);
banner_details_sizer->Add(banner_details, 0, wxEXPAND | wxLEFT | wxRIGHT, space_5);
banner_details_sizer->AddSpacer(space_5);
return banner_details_sizer;
}
wxChoice* InfoPanel::CreateCommentLanguageChoice()
{
const auto languages = m_game_list_item.GetLanguages();
const bool is_wii = m_opened_iso->GetVolumeType() != DiscIO::Platform::GAMECUBE_DISC;
const auto preferred_language = SConfig::GetInstance().GetCurrentLanguage(is_wii);
const int preferred_language_index = FindPreferredLanguageIndex(preferred_language, languages);
const auto choices = GetLanguageChoiceStrings(languages);
auto* const choice = new wxChoice(this, ID_LANGUAGE, wxDefaultPosition, wxDefaultSize, choices);
choice->SetSelection(preferred_language_index);
if (choice->GetCount() <= 1)
choice->Disable();
return choice;
}
void InfoPanel::OnComputeMD5(wxCommandEvent& WXUNUSED(event))
{
wxProgressDialog progress_dialog(_("Computing MD5 checksum"), _("Working..."), 100, this,
wxPD_APP_MODAL | wxPD_AUTO_HIDE | wxPD_CAN_ABORT |
wxPD_ELAPSED_TIME | wxPD_ESTIMATED_TIME |
wxPD_REMAINING_TIME | wxPD_SMOOTH);
const auto result = MD5::MD5Sum(m_game_list_item.GetFileName(), [&progress_dialog](int progress) {
return progress_dialog.Update(progress);
});
if (progress_dialog.WasCancelled())
return;
m_md5_sum->SetValue(result);
}
void InfoPanel::OnChangeBannerLanguage(wxCommandEvent& event)
{
ChangeBannerDetails(m_game_list_item.GetLanguages()[event.GetSelection()]);
}
void InfoPanel::OnRightClickBanner(wxMouseEvent& WXUNUSED(event))
{
wxMenu menu;
menu.Append(IDM_SAVE_BANNER, _("Save as..."));
PopupMenu(&menu);
}
void InfoPanel::OnSaveBannerImage(wxCommandEvent& WXUNUSED(event))
{
wxFileDialog dialog(this, _("Save as..."), wxGetHomeDir(),
wxString::Format("%s.png", m_game_id->GetValue().c_str()),
wxALL_FILES_PATTERN, wxFD_SAVE | wxFD_OVERWRITE_PROMPT);
if (dialog.ShowModal() == wxID_OK)
{
m_game_list_item.GetBannerImage().SaveFile(dialog.GetPath());
}
Raise();
}
void InfoPanel::ChangeBannerDetails(DiscIO::Language language)
{
const auto name = StrToWxStr(m_game_list_item.GetName(language));
const auto comment = StrToWxStr(m_game_list_item.GetDescription(language));
const auto maker = StrToWxStr(m_game_list_item.GetCompany());
m_name->SetValue(name);
m_comment->SetValue(comment);
m_maker->SetValue(maker);
std::string path, filename, extension;
SplitPath(m_game_list_item.GetFileName(), &path, &filename, &extension);
// Real disk drives don't have filenames on Windows
if (filename.empty() && extension.empty())
filename = path + ' ';
const auto game_id = m_game_list_item.GetGameID();
const auto new_title = wxString::Format("%s%s: %s - %s", filename.c_str(), extension.c_str(),
game_id.c_str(), name.c_str());
EmitTitleChangeEvent(new_title);
}
void InfoPanel::EmitTitleChangeEvent(const wxString& new_title)
{
wxCommandEvent event{DOLPHIN_EVT_CHANGE_ISO_PROPERTIES_TITLE, GetId()};
event.SetEventObject(this);
event.SetString(new_title);
AddPendingEvent(event);
}
@@ -0,0 +1,88 @@
// Copyright 2016 Dolphin Emulator Project
// Licensed under GPLv2+
// Refer to the license.txt file included.
#pragma once
#include <memory>
#include <wx/panel.h>
class GameListItem;
class wxButton;
class wxChoice;
class wxStaticBitmap;
class wxStaticBoxSizer;
class wxTextCtrl;
namespace DiscIO
{
class IVolume;
enum class Language;
}
class InfoPanel final : public wxPanel
{
public:
InfoPanel(wxWindow* parent, wxWindowID id, const GameListItem& item,
const std::unique_ptr<DiscIO::IVolume>& opened_iso);
private:
enum
{
ID_NAME = 10000,
ID_GAME_ID,
ID_COUNTRY,
ID_MAKER_ID,
ID_REVISION,
ID_DATE,
ID_FST,
ID_MD5_SUM,
ID_MD5_SUM_COMPUTE,
ID_VERSION,
ID_LANGUAGE,
ID_SHORT_NAME,
ID_MAKER,
ID_COMMENT,
ID_BANNER,
IDM_SAVE_BANNER
};
void CreateGUI();
void BindEvents();
void LoadGUIData();
void LoadISODetails();
void LoadBannerDetails();
void LoadBannerImage();
wxStaticBoxSizer* CreateISODetailsSizer();
wxStaticBoxSizer* CreateBannerDetailsSizer();
wxChoice* CreateCommentLanguageChoice();
void OnComputeMD5(wxCommandEvent&);
void OnChangeBannerLanguage(wxCommandEvent&);
void OnRightClickBanner(wxMouseEvent&);
void OnSaveBannerImage(wxCommandEvent&);
void ChangeBannerDetails(DiscIO::Language language);
void EmitTitleChangeEvent(const wxString& new_title);
const GameListItem& m_game_list_item;
const std::unique_ptr<DiscIO::IVolume>& m_opened_iso;
wxTextCtrl* m_internal_name;
wxTextCtrl* m_game_id;
wxTextCtrl* m_country;
wxTextCtrl* m_maker_id;
wxTextCtrl* m_revision;
wxTextCtrl* m_date;
wxTextCtrl* m_fst;
wxTextCtrl* m_md5_sum;
wxButton* m_md5_sum_compute;
wxChoice* m_languages;
wxTextCtrl* m_name;
wxTextCtrl* m_maker;
wxTextCtrl* m_comment;
wxStaticBitmap* m_banner;
};