mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2024-09-20 19:31:53 +02:00
git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@473 8ced0084-cf51-0410-be5f-012b33b47a6e
This commit is contained in:
nakeee
parent
5fb796fd19
commit
21171d8b1b
31 changed files with 4996 additions and 0 deletions
106
Source/Core/DolphinWX/Src/BootManager.cpp
Normal file
106
Source/Core/DolphinWX/Src/BootManager.cpp
Normal file
|
|
@ -0,0 +1,106 @@
|
|||
// Copyright (C) 2003-2008 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 <string>
|
||||
#include <vector>
|
||||
|
||||
#include "Globals.h"
|
||||
#include "Common.h"
|
||||
#include "IniFile.h"
|
||||
#include "BootManager.h"
|
||||
#include "ISOFile.h"
|
||||
#include "Volume.h"
|
||||
#include "VolumeCreator.h"
|
||||
#include "Config.h"
|
||||
#include "Core.h"
|
||||
#include "Frame.h"
|
||||
#include "CodeWindow.h"
|
||||
|
||||
static std::string s_DataBasePath_EUR = "Data_EUR";
|
||||
static std::string s_DataBasePath_USA = "Data_USA";
|
||||
static std::string s_DataBasePath_JAP = "Data_JAP";
|
||||
|
||||
extern CFrame* main_frame;
|
||||
extern CCodeWindow* g_pCodeWindow;
|
||||
|
||||
namespace BootManager
|
||||
{
|
||||
#ifdef _WIN32
|
||||
extern "C" HINSTANCE wxGetInstance();
|
||||
#endif
|
||||
|
||||
bool BootCore(const std::string& _rFilename)
|
||||
{
|
||||
SCoreStartupParameter StartUp = SConfig::GetInstance().m_LocalCoreStartupParameter;
|
||||
|
||||
if (g_pCodeWindow)
|
||||
{
|
||||
// StartUp.bUseDualCore = code_frame->UseDualCore();
|
||||
StartUp.bUseJIT = !g_pCodeWindow->UseInterpreter();
|
||||
}
|
||||
else
|
||||
{
|
||||
// StartUp.bUseDualCore = false;
|
||||
StartUp.bUseJIT = true;
|
||||
}
|
||||
StartUp.m_BootType = SCoreStartupParameter::BOOT_ISO;
|
||||
StartUp.m_strFilename = _rFilename;
|
||||
StartUp.bRunCompareClient = false;
|
||||
StartUp.bRunCompareServer = false;
|
||||
StartUp.bEnableDebugging = g_pCodeWindow ? true : false; // RUNNING_DEBUG
|
||||
std::string BaseDataPath;
|
||||
#ifdef _WIN32
|
||||
StartUp.hInstance = wxGetInstance();
|
||||
#ifdef _M_X64
|
||||
StartUp.bUseFastMem = true;
|
||||
#endif
|
||||
#endif
|
||||
|
||||
if ( !StartUp.AutoSetup(SCoreStartupParameter::BOOT_DEFAULT) )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// Load overrides
|
||||
IniFile ini;
|
||||
std::string unique_id = StartUp.GetUniqueID();
|
||||
if (unique_id.size() == 6 && ini.Load(("Patches/" + unique_id + ".ini").c_str()))
|
||||
{
|
||||
ini.Get("Core", "UseDualCore", &StartUp.bUseDualCore, StartUp.bUseDualCore);
|
||||
ini.Get("Core", "OptimizeQuantizers", &StartUp.bOptimizeQuantizers, StartUp.bOptimizeQuantizers);
|
||||
}
|
||||
if(main_frame)
|
||||
StartUp.hMainWindow = main_frame->GetRenderHandle();
|
||||
|
||||
// init the core
|
||||
if (!Core::Init(StartUp))
|
||||
{
|
||||
PanicAlert("Couldn't init the core.\nCheck your configuration.");
|
||||
return(false);
|
||||
}
|
||||
|
||||
Core::SetState(g_pCodeWindow ? Core::CORE_PAUSE : Core::CORE_RUN);
|
||||
return(true);
|
||||
}
|
||||
|
||||
|
||||
void Stop()
|
||||
{
|
||||
Core::Stop();
|
||||
}
|
||||
} // namespace
|
||||
|
||||
32
Source/Core/DolphinWX/Src/BootManager.h
Normal file
32
Source/Core/DolphinWX/Src/BootManager.h
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
// Copyright (C) 2003-2008 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/
|
||||
|
||||
#ifndef _BOOTMANAGER_H
|
||||
#define _BOOTMANAGER_H
|
||||
|
||||
#include <string>
|
||||
|
||||
class CISOFile;
|
||||
|
||||
namespace BootManager
|
||||
{
|
||||
bool BootCore(const std::string& _rFilename);
|
||||
|
||||
void Stop();
|
||||
};
|
||||
|
||||
#endif
|
||||
122
Source/Core/DolphinWX/Src/Config.cpp
Normal file
122
Source/Core/DolphinWX/Src/Config.cpp
Normal file
|
|
@ -0,0 +1,122 @@
|
|||
// Copyright (C) 2003-2008 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 <string>
|
||||
|
||||
#include "Globals.h"
|
||||
#include "Common.h"
|
||||
#include "IniFile.h"
|
||||
#include "Config.h"
|
||||
|
||||
SConfig SConfig::m_Instance;
|
||||
|
||||
|
||||
SConfig::SConfig()
|
||||
{
|
||||
LoadSettings();
|
||||
}
|
||||
|
||||
|
||||
SConfig::~SConfig()
|
||||
{
|
||||
SaveSettings();
|
||||
}
|
||||
|
||||
|
||||
void SConfig::SaveSettings()
|
||||
{
|
||||
IniFile ini;
|
||||
ini.Load("Dolphin.ini"); // yes we must load first to not kill unknown stuff
|
||||
|
||||
// misc
|
||||
{
|
||||
ini.Set("General", "LastFilename", m_LastFilename);
|
||||
|
||||
// ISO folders
|
||||
ini.Set("General", "GCMPathes", (int)m_ISOFolder.size());
|
||||
|
||||
for (size_t i = 0; i < m_ISOFolder.size(); i++)
|
||||
{
|
||||
TCHAR tmp[16];
|
||||
sprintf(tmp, "GCMPath%i", (int)i);
|
||||
ini.Set("General", tmp, m_ISOFolder[i]);
|
||||
}
|
||||
}
|
||||
|
||||
// core
|
||||
{
|
||||
ini.Set("Core", "GFXPlugin", m_LocalCoreStartupParameter.m_strVideoPlugin);
|
||||
ini.Set("Core", "DSPPlugin", m_LocalCoreStartupParameter.m_strDSPPlugin);
|
||||
ini.Set("Core", "PadPlugin", m_LocalCoreStartupParameter.m_strPadPlugin);
|
||||
|
||||
ini.Set("Core", "HLEBios", m_LocalCoreStartupParameter.bHLEBios);
|
||||
ini.Set("Core", "UseDynarec", m_LocalCoreStartupParameter.bUseJIT);
|
||||
ini.Set("Core", "UseDualCore", m_LocalCoreStartupParameter.bUseDualCore);
|
||||
ini.Set("Core", "LockThreads", m_LocalCoreStartupParameter.bLockThreads);
|
||||
ini.Set("Core", "DefaultGCM", m_LocalCoreStartupParameter.m_strDefaultGCM);
|
||||
ini.Set("Core", "OptimizeQuantizers", m_LocalCoreStartupParameter.bOptimizeQuantizers);
|
||||
}
|
||||
|
||||
ini.Save("Dolphin.ini");
|
||||
}
|
||||
|
||||
|
||||
void SConfig::LoadSettings()
|
||||
{
|
||||
IniFile ini;
|
||||
ini.Load("Dolphin.ini");
|
||||
|
||||
// hard coded default plugin
|
||||
{
|
||||
ini.Get("Default", "GFXPlugin", &m_DefaultGFXPlugin);
|
||||
ini.Get("Default", "DSPPlugin", &m_DefaultDSPPlugin);
|
||||
ini.Get("Default", "PadPlugin", &m_DefaultPADPlugin);
|
||||
}
|
||||
|
||||
// misc
|
||||
{
|
||||
ini.Get("General", "LastFilename", &m_LastFilename);
|
||||
|
||||
m_ISOFolder.clear();
|
||||
int numGCMPaths;
|
||||
|
||||
if (ini.Get("General", "GCMPathes", &numGCMPaths, 0))
|
||||
{
|
||||
for (int i = 0; i < numGCMPaths; i++)
|
||||
{
|
||||
TCHAR tmp[16];
|
||||
sprintf(tmp, "GCMPath%i", i);
|
||||
std::string tmpPath;
|
||||
ini.Get("General", tmp, &tmpPath, "");
|
||||
m_ISOFolder.push_back(tmpPath);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// core
|
||||
{
|
||||
ini.Get("Core", "GFXPlugin", &m_LocalCoreStartupParameter.m_strVideoPlugin, m_DefaultGFXPlugin.c_str());
|
||||
ini.Get("Core", "DSPPlugin", &m_LocalCoreStartupParameter.m_strDSPPlugin, m_DefaultDSPPlugin.c_str());
|
||||
ini.Get("Core", "PadPlugin", &m_LocalCoreStartupParameter.m_strPadPlugin, m_DefaultPADPlugin.c_str());
|
||||
|
||||
ini.Get("Core", "HLEBios", &m_LocalCoreStartupParameter.bHLEBios, true);
|
||||
ini.Get("Core", "UseDynarec", &m_LocalCoreStartupParameter.bUseJIT, true);
|
||||
ini.Get("Core", "UseDualCore", &m_LocalCoreStartupParameter.bUseDualCore, false);
|
||||
ini.Get("Core", "LockThreads", &m_LocalCoreStartupParameter.bLockThreads, true);
|
||||
ini.Get("Core", "OptimizeQuantizers", &m_LocalCoreStartupParameter.bOptimizeQuantizers, true);
|
||||
}
|
||||
}
|
||||
63
Source/Core/DolphinWX/Src/Config.h
Normal file
63
Source/Core/DolphinWX/Src/Config.h
Normal file
|
|
@ -0,0 +1,63 @@
|
|||
// Copyright (C) 2003-2008 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/
|
||||
|
||||
#ifndef _CONFIG_H
|
||||
#define _CONFIG_H
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include "Boot/Boot.h"
|
||||
|
||||
struct SConfig
|
||||
{
|
||||
// default plugins ... hard coded inside the ini
|
||||
std::string m_DefaultGFXPlugin;
|
||||
std::string m_DefaultDSPPlugin;
|
||||
std::string m_DefaultPADPlugin;
|
||||
|
||||
// name of the last used filename
|
||||
std::string m_LastFilename;
|
||||
|
||||
// gcm folder
|
||||
std::vector<std::string>m_ISOFolder;
|
||||
|
||||
SCoreStartupParameter m_LocalCoreStartupParameter;
|
||||
|
||||
// save settings
|
||||
void SaveSettings();
|
||||
|
||||
|
||||
// load settings
|
||||
void LoadSettings();
|
||||
|
||||
|
||||
static SConfig& GetInstance() {return(m_Instance);}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// constructor
|
||||
SConfig();
|
||||
|
||||
// destructor
|
||||
~SConfig();
|
||||
|
||||
static SConfig m_Instance;
|
||||
};
|
||||
|
||||
#endif
|
||||
115
Source/Core/DolphinWX/Src/FileSearch.cpp
Normal file
115
Source/Core/DolphinWX/Src/FileSearch.cpp
Normal file
|
|
@ -0,0 +1,115 @@
|
|||
// Copyright (C) 2003-2008 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 "Globals.h"
|
||||
#ifndef _WIN32
|
||||
#include <sys/types.h>
|
||||
#include <dirent.h>
|
||||
#else
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
#include <string>
|
||||
|
||||
#include "FileSearch.h"
|
||||
|
||||
#include "StringUtil.h"
|
||||
|
||||
|
||||
CFileSearch::CFileSearch(const CFileSearch::XStringVector& _rSearchStrings, const CFileSearch::XStringVector& _rDirectories)
|
||||
{
|
||||
// Reverse the loop order for speed?
|
||||
for (size_t j = 0; j < _rSearchStrings.size(); j++)
|
||||
{
|
||||
for (size_t i = 0; i < _rDirectories.size(); i++)
|
||||
{
|
||||
FindFiles(_rSearchStrings[j], _rDirectories[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void CFileSearch::FindFiles(const std::string& _searchString, const std::string& _strPath)
|
||||
{
|
||||
std::string GCMSearchPath;
|
||||
BuildCompleteFilename(GCMSearchPath, _strPath, _searchString);
|
||||
#ifdef _WIN32
|
||||
WIN32_FIND_DATA findData;
|
||||
HANDLE FindFirst = FindFirstFile(GCMSearchPath.c_str(), &findData);
|
||||
|
||||
if (FindFirst != INVALID_HANDLE_VALUE)
|
||||
{
|
||||
bool bkeepLooping = true;
|
||||
|
||||
while (bkeepLooping)
|
||||
{
|
||||
std::string strFilename;
|
||||
BuildCompleteFilename(strFilename, _strPath, findData.cFileName);
|
||||
|
||||
m_FileNames.push_back(strFilename);
|
||||
|
||||
bkeepLooping = FindNextFile(FindFirst, &findData) ? true : false;
|
||||
}
|
||||
}
|
||||
|
||||
#else
|
||||
size_t dot_pos = _searchString.rfind(".");
|
||||
|
||||
if (dot_pos == std::string::npos)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
std::string ext = _searchString.substr(dot_pos);
|
||||
DIR* dir = opendir(_strPath.c_str());
|
||||
|
||||
if (!dir)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
dirent* dp;
|
||||
|
||||
while (true)
|
||||
{
|
||||
dp = readdir(dir);
|
||||
|
||||
if (!dp)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
std::string s(dp->d_name);
|
||||
|
||||
if ( (s.size() > ext.size()) && (!strcasecmp(s.substr(s.size() - ext.size()).c_str(), ext.c_str())) )
|
||||
{
|
||||
std::string full_name = _strPath + "/" + s;
|
||||
m_FileNames.push_back(full_name);
|
||||
}
|
||||
}
|
||||
|
||||
closedir(dir);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
const CFileSearch::XStringVector& CFileSearch::GetFileNames() const
|
||||
{
|
||||
return(m_FileNames);
|
||||
}
|
||||
|
||||
|
||||
44
Source/Core/DolphinWX/Src/FileSearch.h
Normal file
44
Source/Core/DolphinWX/Src/FileSearch.h
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
// Copyright (C) 2003-2008 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/
|
||||
|
||||
#ifndef __FILESEARCH_H_
|
||||
#define __FILESEARCH_H_
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
class CFileSearch
|
||||
{
|
||||
public:
|
||||
|
||||
typedef std::vector<std::string>XStringVector;
|
||||
|
||||
CFileSearch(const XStringVector& _rSearchStrings, const XStringVector& _rDirectories);
|
||||
|
||||
const XStringVector& GetFileNames() const;
|
||||
|
||||
|
||||
private:
|
||||
|
||||
void FindFiles(const std::string& _searchString, const std::string& _strPath);
|
||||
|
||||
|
||||
XStringVector m_FileNames;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
632
Source/Core/DolphinWX/Src/Frame.cpp
Normal file
632
Source/Core/DolphinWX/Src/Frame.cpp
Normal file
|
|
@ -0,0 +1,632 @@
|
|||
// Copyright (C) 2003-2008 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 "Globals.h"
|
||||
#include "Frame.h"
|
||||
#include "FileUtil.h"
|
||||
|
||||
#include "GameListCtrl.h"
|
||||
#include "BootManager.h"
|
||||
|
||||
#include "Common.h"
|
||||
#include "Config.h"
|
||||
#include "Core.h"
|
||||
#include "State.h"
|
||||
#include "PluginOptions.h"
|
||||
#include "PluginManager.h"
|
||||
#include "MemcardManager.h"
|
||||
|
||||
#include <wx/mstream.h>
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// resources
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
extern "C" {
|
||||
#include "../resources/Dolphin.c"
|
||||
#include "../resources/toolbar_browse.c"
|
||||
#include "../resources/toolbar_file_open.c"
|
||||
#include "../resources/toolbar_fullscreen.c"
|
||||
#include "../resources/toolbar_help.c"
|
||||
#include "../resources/toolbar_pause.c"
|
||||
#include "../resources/toolbar_play.c"
|
||||
#include "../resources/toolbar_play_dis.c"
|
||||
#include "../resources/toolbar_plugin_dsp.c"
|
||||
#include "../resources/toolbar_plugin_gfx.c"
|
||||
#include "../resources/toolbar_plugin_options.c"
|
||||
#include "../resources/toolbar_plugin_options_dis.c"
|
||||
#include "../resources/toolbar_plugin_pad.c"
|
||||
#include "../resources/toolbar_refresh.c"
|
||||
#include "../resources/toolbar_stop.c"
|
||||
#include "../resources/toolbar_stop_dis.c"
|
||||
};
|
||||
|
||||
#define wxGetBitmapFromMemory(name) _wxGetBitmapFromMemory(name, sizeof(name))
|
||||
inline wxBitmap _wxGetBitmapFromMemory(const unsigned char* data, int length)
|
||||
{
|
||||
wxMemoryInputStream is(data, length);
|
||||
return(wxBitmap(wxImage(is, wxBITMAP_TYPE_ANY, -1), -1));
|
||||
}
|
||||
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// constants
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
static const long TOOLBAR_STYLE = wxTB_FLAT | wxTB_DOCKABLE | wxTB_TEXT;
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// event tables
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
// Notice that wxID_HELP will be processed for the 'About' menu and the toolbar
|
||||
// help button.
|
||||
|
||||
const wxEventType wxEVT_HOST_COMMAND = wxNewEventType();
|
||||
|
||||
BEGIN_EVENT_TABLE(CFrame, wxFrame)
|
||||
EVT_MENU(wxID_OPEN, CFrame::OnOpen)
|
||||
EVT_MENU(wxID_EXIT, CFrame::OnQuit)
|
||||
EVT_MENU(IDM_HELPWEBSITE, CFrame::OnHelp)
|
||||
EVT_MENU(IDM_HELPGOOGLECODE, CFrame::OnHelp)
|
||||
EVT_MENU(IDM_HELPABOUT, CFrame::OnHelp)
|
||||
EVT_MENU(wxID_REFRESH, CFrame::OnRefresh)
|
||||
EVT_MENU(IDM_PLAY, CFrame::OnPlay)
|
||||
EVT_MENU(IDM_STOP, CFrame::OnStop)
|
||||
EVT_MENU(IDM_PLUGIN_OPTIONS, CFrame::OnPluginOptions)
|
||||
EVT_MENU(IDM_CONFIG_GFX_PLUGIN, CFrame::OnPluginGFX)
|
||||
EVT_MENU(IDM_CONFIG_DSP_PLUGIN, CFrame::OnPluginDSP)
|
||||
EVT_MENU(IDM_CONFIG_PAD_PLUGIN, CFrame::OnPluginPAD)
|
||||
EVT_MENU(IDM_BROWSE, CFrame::OnBrowse)
|
||||
EVT_MENU(IDM_MEMCARD, CFrame::OnMemcard)
|
||||
EVT_MENU(IDM_TOGGLE_FULLSCREEN, CFrame::OnToggleFullscreen)
|
||||
EVT_MENU(IDM_TOGGLE_DUALCORE, CFrame::OnToggleDualCore)
|
||||
EVT_MENU(IDM_TOGGLE_TOOLBAR, CFrame::OnToggleToolbar)
|
||||
EVT_MENU(IDM_LOADSLOT1, CFrame::OnLoadState)
|
||||
EVT_MENU(IDM_LOADSLOT2, CFrame::OnLoadState)
|
||||
EVT_MENU(IDM_LOADSLOT3, CFrame::OnLoadState)
|
||||
EVT_MENU(IDM_LOADSLOT4, CFrame::OnLoadState)
|
||||
EVT_MENU(IDM_LOADSLOT5, CFrame::OnLoadState)
|
||||
EVT_MENU(IDM_LOADSLOT6, CFrame::OnLoadState)
|
||||
EVT_MENU(IDM_LOADSLOT7, CFrame::OnLoadState)
|
||||
EVT_MENU(IDM_LOADSLOT8, CFrame::OnLoadState)
|
||||
EVT_MENU(IDM_LOADSLOT9, CFrame::OnLoadState)
|
||||
EVT_MENU(IDM_LOADSLOT10, CFrame::OnLoadState)
|
||||
EVT_MENU(IDM_SAVESLOT1, CFrame::OnSaveState)
|
||||
EVT_MENU(IDM_SAVESLOT2, CFrame::OnSaveState)
|
||||
EVT_MENU(IDM_SAVESLOT3, CFrame::OnSaveState)
|
||||
EVT_MENU(IDM_SAVESLOT4, CFrame::OnSaveState)
|
||||
EVT_MENU(IDM_SAVESLOT5, CFrame::OnSaveState)
|
||||
EVT_MENU(IDM_SAVESLOT6, CFrame::OnSaveState)
|
||||
EVT_MENU(IDM_SAVESLOT7, CFrame::OnSaveState)
|
||||
EVT_MENU(IDM_SAVESLOT8, CFrame::OnSaveState)
|
||||
EVT_MENU(IDM_SAVESLOT9, CFrame::OnSaveState)
|
||||
EVT_MENU(IDM_SAVESLOT10, CFrame::OnSaveState)
|
||||
EVT_HOST_COMMAND(wxID_ANY, CFrame::OnHostMessage)
|
||||
END_EVENT_TABLE()
|
||||
|
||||
// ----------------------------------------------------------------------------
|
||||
// implementation
|
||||
// ----------------------------------------------------------------------------
|
||||
|
||||
CFrame::CFrame(wxFrame* parent,
|
||||
wxWindowID id,
|
||||
const wxString& title,
|
||||
const wxPoint& pos,
|
||||
const wxSize& size,
|
||||
long style)
|
||||
: wxFrame(parent, id, title, pos, size, style)
|
||||
, m_Panel(NULL)
|
||||
, m_pStatusBar(NULL)
|
||||
, m_pMenuBar(NULL)
|
||||
, m_pBootProcessDialog(NULL)
|
||||
{
|
||||
InitBitmaps();
|
||||
|
||||
// Give it an icon
|
||||
wxIcon IconTemp;
|
||||
IconTemp.CopyFromBitmap(wxGetBitmapFromMemory(dolphin_png));
|
||||
SetIcon(IconTemp);
|
||||
|
||||
// Give it a status line
|
||||
m_pStatusBar = CreateStatusBar();
|
||||
CreateMenu();
|
||||
|
||||
// this panel is the parent for rendering and it holds the gamelistctrl
|
||||
{
|
||||
m_Panel = new wxPanel(this);
|
||||
|
||||
m_GameListCtrl = new CGameListCtrl(m_Panel, LIST_CTRL,
|
||||
wxDefaultPosition, wxDefaultSize,
|
||||
wxLC_REPORT | wxSUNKEN_BORDER | wxLC_ALIGN_LEFT | wxLC_SINGLE_SEL | wxLC_SORT_ASCENDING);
|
||||
|
||||
wxBoxSizer* sizerPanel = new wxBoxSizer(wxHORIZONTAL);
|
||||
sizerPanel->Add(m_GameListCtrl, 2, wxEXPAND | wxALL);
|
||||
m_Panel->SetSizer(sizerPanel);
|
||||
|
||||
sizerPanel->SetSizeHints(m_Panel);
|
||||
sizerPanel->Fit(m_Panel);
|
||||
}
|
||||
|
||||
// Create the toolbar
|
||||
RecreateToolbar();
|
||||
|
||||
Show();
|
||||
|
||||
CPluginManager::GetInstance().ScanForPlugins(this);
|
||||
|
||||
m_GameListCtrl->Update();
|
||||
|
||||
wxTheApp->Connect(wxID_ANY, wxEVT_KEY_DOWN,
|
||||
wxKeyEventHandler(CFrame::OnKeyDown),
|
||||
(wxObject*)0, this);
|
||||
|
||||
UpdateGUI();
|
||||
}
|
||||
|
||||
|
||||
void CFrame::CreateMenu()
|
||||
{
|
||||
delete m_pMenuBar;
|
||||
m_pMenuBar = new wxMenuBar(wxMB_DOCKABLE);
|
||||
|
||||
// file menu
|
||||
wxMenu* fileMenu = new wxMenu;
|
||||
fileMenu->Append(wxID_OPEN, _T("&Open...\tCtrl+O"));
|
||||
fileMenu->Append(wxID_REFRESH, _T("&Refresh"));
|
||||
fileMenu->Append(IDM_BROWSE, _T("&Browse for ISOs..."));
|
||||
|
||||
fileMenu->AppendSeparator();
|
||||
fileMenu->Append(wxID_EXIT, _T("E&xit"), _T("Alt+F4"));
|
||||
m_pMenuBar->Append(fileMenu, _T("&File"));
|
||||
|
||||
// emulation menu
|
||||
wxMenu* emulationMenu = new wxMenu;
|
||||
m_pMenuItemPlay = emulationMenu->Append(IDM_PLAY, _T("&Play"));
|
||||
m_pMenuItemStop = emulationMenu->Append(IDM_STOP, _T("&Stop"));
|
||||
emulationMenu->AppendSeparator();
|
||||
wxMenu *saveMenu = new wxMenu;
|
||||
wxMenu *loadMenu = new wxMenu;
|
||||
m_pMenuItemLoad = emulationMenu->AppendSubMenu(saveMenu, _T("&Load State"));
|
||||
m_pMenuItemSave = emulationMenu->AppendSubMenu(loadMenu, _T("Sa&ve State"));
|
||||
for (int i = 1; i < 10; i++) {
|
||||
saveMenu->Append(IDM_LOADSLOT1 + i - 1, wxString::Format(_T("Slot %i F%i"), i, i));
|
||||
loadMenu->Append(IDM_SAVESLOT1 + i - 1, wxString::Format(_T("Slot %i Shift+F%i"), i, i));
|
||||
}
|
||||
m_pMenuBar->Append(emulationMenu, _T("&Emulation"));
|
||||
|
||||
// options menu
|
||||
wxMenu* pOptionsMenu = new wxMenu;
|
||||
m_pPluginOptions = pOptionsMenu->Append(IDM_PLUGIN_OPTIONS, _T("&Select plugins"));
|
||||
pOptionsMenu->AppendSeparator();
|
||||
pOptionsMenu->Append(IDM_CONFIG_GFX_PLUGIN, _T("&GFX settings"));
|
||||
pOptionsMenu->Append(IDM_CONFIG_DSP_PLUGIN, _T("&DSP settings"));
|
||||
pOptionsMenu->Append(IDM_CONFIG_PAD_PLUGIN, _T("&PAD settings"));
|
||||
pOptionsMenu->AppendSeparator();
|
||||
pOptionsMenu->Append(IDM_TOGGLE_FULLSCREEN, _T("&Fullscreen"));
|
||||
pOptionsMenu->AppendCheckItem(IDM_TOGGLE_DUALCORE, _T("&Dual-core (unstable!)"));
|
||||
pOptionsMenu->Check(IDM_TOGGLE_DUALCORE, SConfig::GetInstance().m_LocalCoreStartupParameter.bUseDualCore);
|
||||
m_pMenuBar->Append(pOptionsMenu, _T("&Options"));
|
||||
|
||||
// misc menu
|
||||
wxMenu* miscMenu = new wxMenu;
|
||||
miscMenu->Append(IDM_MEMCARD, _T("&Memcard manager"));
|
||||
miscMenu->AppendCheckItem(IDM_TOGGLE_TOOLBAR, _T("&Enable toolbar"));
|
||||
miscMenu->Check(IDM_TOGGLE_TOOLBAR, true);
|
||||
m_pMenuBar->Append(miscMenu, _T("&Misc"));
|
||||
|
||||
// help menu
|
||||
wxMenu* helpMenu = new wxMenu;
|
||||
/*helpMenu->Append(wxID_HELP, _T("&Help"));
|
||||
re-enable when there's something useful to display*/
|
||||
helpMenu->Append(IDM_HELPWEBSITE, _T("&Dolphin web site"));
|
||||
helpMenu->Append(IDM_HELPGOOGLECODE, _T("&Dolphin at Google Code"));
|
||||
helpMenu->AppendSeparator();
|
||||
helpMenu->Append(IDM_HELPABOUT, _T("&About..."));
|
||||
m_pMenuBar->Append(helpMenu, _T("&Help"));
|
||||
|
||||
// Associate the menu bar with the frame
|
||||
SetMenuBar(m_pMenuBar);
|
||||
}
|
||||
|
||||
|
||||
void CFrame::PopulateToolbar(wxToolBar* toolBar)
|
||||
{
|
||||
int w = m_Bitmaps[Toolbar_FileOpen].GetWidth(),
|
||||
h = m_Bitmaps[Toolbar_FileOpen].GetHeight();
|
||||
|
||||
toolBar->SetToolBitmapSize(wxSize(w, h));
|
||||
toolBar->AddTool(wxID_OPEN, _T("Open"), m_Bitmaps[Toolbar_FileOpen], _T("Open file..."));
|
||||
toolBar->AddTool(wxID_REFRESH, _T("Refresh"), m_Bitmaps[Toolbar_Refresh], _T("Refresh"));
|
||||
toolBar->AddTool(IDM_BROWSE, _T("Browse"), m_Bitmaps[Toolbar_Browse], _T("Browse for an ISO directory..."));
|
||||
toolBar->AddSeparator();
|
||||
toolBar->AddTool(IDM_PLAY, _T("Play"), m_Bitmaps[Toolbar_Play], _T("Play"));
|
||||
toolBar->SetToolDisabledBitmap(IDM_PLAY, m_Bitmaps[Toolbar_Play_Dis]);
|
||||
toolBar->AddTool(IDM_STOP, _T("Stop"), m_Bitmaps[Toolbar_Stop], _T("Stop"));
|
||||
toolBar->SetToolDisabledBitmap(IDM_STOP, m_Bitmaps[Toolbar_Stop_Dis]);
|
||||
toolBar->AddTool(IDM_TOGGLE_FULLSCREEN, _T("Fullscr."), m_Bitmaps[Toolbar_FullScreen], _T("Toggle Fullscreen"));
|
||||
toolBar->AddSeparator();
|
||||
toolBar->AddTool(IDM_PLUGIN_OPTIONS, _T("Plugins"), m_Bitmaps[Toolbar_PluginOptions], _T("Select plugins"));
|
||||
toolBar->SetToolDisabledBitmap(IDM_PLUGIN_OPTIONS, m_Bitmaps[Toolbar_PluginOptions_Dis]);
|
||||
toolBar->AddTool(IDM_CONFIG_GFX_PLUGIN, _T("GFX"), m_Bitmaps[Toolbar_PluginGFX], _T("GFX settings"));
|
||||
toolBar->AddTool(IDM_CONFIG_DSP_PLUGIN, _T("DSP"), m_Bitmaps[Toolbar_PluginDSP], _T("DSP settings"));
|
||||
toolBar->AddTool(IDM_CONFIG_PAD_PLUGIN, _T("PAD"), m_Bitmaps[Toolbar_PluginPAD], _T("PAD settings"));
|
||||
toolBar->AddSeparator();
|
||||
toolBar->AddTool(IDM_HELPABOUT, _T("About"), m_Bitmaps[Toolbar_Help], _T("About Dolphin"));
|
||||
|
||||
// after adding the buttons to the toolbar, must call Realize() to reflect
|
||||
// the changes
|
||||
toolBar->Realize();
|
||||
}
|
||||
|
||||
|
||||
void CFrame::RecreateToolbar()
|
||||
{
|
||||
// delete and recreate the toolbar
|
||||
wxToolBarBase* toolBar = GetToolBar();
|
||||
long style = toolBar ? toolBar->GetWindowStyle() : TOOLBAR_STYLE;
|
||||
|
||||
delete toolBar;
|
||||
SetToolBar(NULL);
|
||||
|
||||
style &= ~(wxTB_HORIZONTAL | wxTB_VERTICAL | wxTB_BOTTOM | wxTB_RIGHT | wxTB_HORZ_LAYOUT | wxTB_TOP);
|
||||
wxToolBar* theToolBar = CreateToolBar(style, ID_TOOLBAR);
|
||||
|
||||
PopulateToolbar(theToolBar);
|
||||
SetToolBar(theToolBar);
|
||||
}
|
||||
|
||||
|
||||
void CFrame::InitBitmaps()
|
||||
{
|
||||
// load orignal size 48x48
|
||||
m_Bitmaps[Toolbar_FileOpen] = wxGetBitmapFromMemory(toolbar_file_open_png);
|
||||
m_Bitmaps[Toolbar_Refresh] = wxGetBitmapFromMemory(toolbar_refresh_png);
|
||||
m_Bitmaps[Toolbar_Browse] = wxGetBitmapFromMemory(toolbar_browse_png);
|
||||
m_Bitmaps[Toolbar_Play] = wxGetBitmapFromMemory(toolbar_play_png);
|
||||
m_Bitmaps[Toolbar_Play_Dis] = wxGetBitmapFromMemory(toolbar_play_dis_png);
|
||||
m_Bitmaps[Toolbar_Stop] = wxGetBitmapFromMemory(toolbar_stop_png);
|
||||
m_Bitmaps[Toolbar_Stop_Dis] = wxGetBitmapFromMemory(toolbar_stop_dis_png);
|
||||
m_Bitmaps[Toolbar_Pause] = wxGetBitmapFromMemory(toolbar_pause_png);
|
||||
m_Bitmaps[Toolbar_PluginOptions] = wxGetBitmapFromMemory(toolbar_plugin_options_png);
|
||||
m_Bitmaps[Toolbar_PluginOptions_Dis] = wxGetBitmapFromMemory(toolbar_plugin_options_dis_png);
|
||||
m_Bitmaps[Toolbar_PluginGFX] = wxGetBitmapFromMemory(toolbar_plugin_gfx_png);
|
||||
m_Bitmaps[Toolbar_PluginDSP] = wxGetBitmapFromMemory(toolbar_plugin_dsp_png);
|
||||
m_Bitmaps[Toolbar_PluginPAD] = wxGetBitmapFromMemory(toolbar_plugin_pad_png);
|
||||
m_Bitmaps[Toolbar_FullScreen] = wxGetBitmapFromMemory(toolbar_fullscreen_png);
|
||||
m_Bitmaps[Toolbar_Help] = wxGetBitmapFromMemory(toolbar_help_png);
|
||||
|
||||
// scale to 24x24 for toolbar
|
||||
for (size_t n = Toolbar_FileOpen; n < WXSIZEOF(m_Bitmaps); n++)
|
||||
{
|
||||
m_Bitmaps[n] = wxBitmap(m_Bitmaps[n].ConvertToImage().Scale(24, 24));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void CFrame::OnOpen(wxCommandEvent& WXUNUSED (event))
|
||||
{
|
||||
if (Core::GetState() != Core::CORE_UNINITIALIZED)
|
||||
return;
|
||||
wxString path = wxFileSelector(
|
||||
_T("Select the file to load"),
|
||||
wxEmptyString, wxEmptyString, wxEmptyString,
|
||||
wxString::Format
|
||||
(
|
||||
_T("All GC/Wii files (elf, dol, gcm, iso)|*.elf;*.dol;*.gcm;*.iso|All files (%s)|%s"),
|
||||
wxFileSelectorDefaultWildcardStr,
|
||||
wxFileSelectorDefaultWildcardStr
|
||||
),
|
||||
wxFD_OPEN | wxFD_PREVIEW | wxFD_FILE_MUST_EXIST,
|
||||
this);
|
||||
if (!path)
|
||||
{
|
||||
return;
|
||||
}
|
||||
BootManager::BootCore(std::string(path.ToAscii()));
|
||||
}
|
||||
|
||||
|
||||
void CFrame::OnQuit(wxCommandEvent& WXUNUSED (event))
|
||||
{
|
||||
if (Core::GetState() != Core::CORE_UNINITIALIZED)
|
||||
{
|
||||
Core::Stop();
|
||||
UpdateGUI();
|
||||
}
|
||||
|
||||
Close(true);
|
||||
}
|
||||
|
||||
|
||||
void CFrame::OnHelp(wxCommandEvent& event)
|
||||
{
|
||||
switch (event.GetId()) {
|
||||
case IDM_HELPABOUT:
|
||||
{
|
||||
wxAboutDialogInfo info;
|
||||
info.AddDeveloper(_T("ector"));
|
||||
info.AddDeveloper(_T("F|RES"));
|
||||
info.AddDeveloper(_T("yaz0r"));
|
||||
info.AddDeveloper(_T("zerofrog"));
|
||||
/* info.SetLicence(wxString::FromAscii(
|
||||
"Dolphin Licence 1.0"
|
||||
"#include GPL.TXT"));
|
||||
*/
|
||||
|
||||
info.AddArtist(_T("miloszwl@miloszwl.com (miloszwl.deviantart.com)"));
|
||||
|
||||
wxAboutBox(info);
|
||||
break;
|
||||
}
|
||||
case IDM_HELPWEBSITE:
|
||||
File::Launch("http://www.dolphin-emu.com/");
|
||||
break;
|
||||
case IDM_HELPGOOGLECODE:
|
||||
File::Launch("http://code.google.com/p/dolphin-emu/");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void CFrame::OnPlay(wxCommandEvent& WXUNUSED (event))
|
||||
{
|
||||
if (Core::GetState() != Core::CORE_UNINITIALIZED)
|
||||
{
|
||||
if (Core::GetState() == Core::CORE_RUN)
|
||||
{
|
||||
Core::SetState(Core::CORE_PAUSE);
|
||||
}
|
||||
else
|
||||
{
|
||||
Core::SetState(Core::CORE_RUN);
|
||||
}
|
||||
|
||||
UpdateGUI();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void CFrame::OnStop(wxCommandEvent& WXUNUSED (event))
|
||||
{
|
||||
if (Core::GetState() != Core::CORE_UNINITIALIZED)
|
||||
{
|
||||
Core::Stop();
|
||||
UpdateGUI();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void CFrame::OnRefresh(wxCommandEvent& WXUNUSED (event))
|
||||
{
|
||||
if (m_GameListCtrl)
|
||||
{
|
||||
m_GameListCtrl->Update();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void CFrame::OnPluginOptions(wxCommandEvent& WXUNUSED (event))
|
||||
{
|
||||
CPluginOptions PluginOptions(this);
|
||||
PluginOptions.ShowModal();
|
||||
}
|
||||
|
||||
|
||||
void CFrame::OnPluginGFX(wxCommandEvent& WXUNUSED (event))
|
||||
{
|
||||
CPluginManager::GetInstance().OpenConfig(
|
||||
GetHandle(),
|
||||
SConfig::GetInstance().m_LocalCoreStartupParameter.m_strVideoPlugin
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
void CFrame::OnPluginDSP(wxCommandEvent& WXUNUSED (event))
|
||||
{
|
||||
CPluginManager::GetInstance().OpenConfig(
|
||||
GetHandle(),
|
||||
SConfig::GetInstance().m_LocalCoreStartupParameter.m_strDSPPlugin
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
void CFrame::OnPluginPAD(wxCommandEvent& WXUNUSED (event))
|
||||
{
|
||||
CPluginManager::GetInstance().OpenConfig(
|
||||
GetHandle(),
|
||||
SConfig::GetInstance().m_LocalCoreStartupParameter.m_strPadPlugin
|
||||
);
|
||||
}
|
||||
|
||||
void CFrame::OnBrowse(wxCommandEvent& WXUNUSED (event))
|
||||
{
|
||||
m_GameListCtrl->BrowseForDirectory();
|
||||
}
|
||||
|
||||
void CFrame::OnMemcard(wxCommandEvent& WXUNUSED (event))
|
||||
{
|
||||
CMemcardManager MemcardManager(this);
|
||||
MemcardManager.ShowModal();
|
||||
}
|
||||
|
||||
void CFrame::OnHostMessage(wxCommandEvent& event)
|
||||
{
|
||||
switch (event.GetId())
|
||||
{
|
||||
case IDM_UPDATEGUI:
|
||||
UpdateGUI();
|
||||
break;
|
||||
|
||||
case IDM_BOOTING_STARTED:
|
||||
if (m_pBootProcessDialog == NULL)
|
||||
{
|
||||
/* m_pBootProcessDialog = new wxProgressDialog
|
||||
(_T("Booting the core"),
|
||||
_T("Booting..."),
|
||||
1, // range
|
||||
this,
|
||||
wxPD_APP_MODAL |
|
||||
// wxPD_AUTO_HIDE | -- try this as well
|
||||
wxPD_ELAPSED_TIME |
|
||||
wxPD_SMOOTH // - makes indeterminate mode bar on WinXP very small
|
||||
);*/
|
||||
|
||||
m_pBootProcessDialog = new wxBusyInfo(wxString::FromAscii("Booting..."), this);
|
||||
}
|
||||
break;
|
||||
|
||||
case IDM_BOOTING_ENDED:
|
||||
if (m_pBootProcessDialog != NULL)
|
||||
{
|
||||
// m_pBootProcessDialog->Destroy();
|
||||
delete m_pBootProcessDialog;
|
||||
m_pBootProcessDialog = NULL;
|
||||
}
|
||||
break;
|
||||
|
||||
case IDM_UPDATESTATUSBAR:
|
||||
if (m_pStatusBar != NULL)
|
||||
{
|
||||
m_pStatusBar->SetStatusText(event.GetString());
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void CFrame::OnToggleFullscreen(wxCommandEvent& WXUNUSED (event))
|
||||
{
|
||||
ShowFullScreen(true);
|
||||
UpdateGUI();
|
||||
}
|
||||
|
||||
void CFrame::OnToggleDualCore(wxCommandEvent& WXUNUSED (event))
|
||||
{
|
||||
SConfig::GetInstance().m_LocalCoreStartupParameter.bUseDualCore = !SConfig::GetInstance().m_LocalCoreStartupParameter.bUseDualCore;
|
||||
SConfig::GetInstance().SaveSettings();
|
||||
}
|
||||
|
||||
void CFrame::OnLoadState(wxCommandEvent& event)
|
||||
{
|
||||
int id = event.GetId();
|
||||
int slot = id - IDM_LOADSLOT1 + 1;
|
||||
State_Load(slot);
|
||||
}
|
||||
|
||||
void CFrame::OnSaveState(wxCommandEvent& event)
|
||||
{
|
||||
int id = event.GetId();
|
||||
int slot = id - IDM_SAVESLOT1 + 1;
|
||||
State_Save(slot);
|
||||
}
|
||||
|
||||
void CFrame::OnToggleToolbar(wxCommandEvent& event)
|
||||
{
|
||||
wxToolBarBase* toolBar = GetToolBar();
|
||||
|
||||
if (event.IsChecked())
|
||||
{
|
||||
CFrame::RecreateToolbar();
|
||||
}
|
||||
else
|
||||
{
|
||||
delete toolBar;
|
||||
SetToolBar(NULL);
|
||||
}
|
||||
}
|
||||
|
||||
void CFrame::OnKeyDown(wxKeyEvent& event)
|
||||
{
|
||||
if (((event.GetKeyCode() == WXK_RETURN) && (event.GetModifiers() == wxMOD_ALT)) ||
|
||||
(event.GetKeyCode() == WXK_ESCAPE))
|
||||
{
|
||||
ShowFullScreen(!IsFullScreen());
|
||||
UpdateGUI();
|
||||
}
|
||||
else
|
||||
{
|
||||
event.Skip();
|
||||
}
|
||||
}
|
||||
|
||||
void CFrame::UpdateGUI()
|
||||
{
|
||||
// buttons
|
||||
{
|
||||
if (Core::GetState() == Core::CORE_UNINITIALIZED)
|
||||
{
|
||||
GetToolBar()->EnableTool(IDM_PLUGIN_OPTIONS, true);
|
||||
m_pPluginOptions->Enable(true);
|
||||
|
||||
GetToolBar()->EnableTool(IDM_STOP, false);
|
||||
GetToolBar()->EnableTool(IDM_PLAY, false);
|
||||
|
||||
m_pMenuItemPlay->Enable(false);
|
||||
m_pMenuItemStop->Enable(false);
|
||||
m_pMenuItemLoad->Enable(false);
|
||||
m_pMenuItemSave->Enable(false);
|
||||
}
|
||||
else
|
||||
{
|
||||
GetToolBar()->EnableTool(IDM_PLUGIN_OPTIONS, false);
|
||||
m_pPluginOptions->Enable(false);
|
||||
|
||||
GetToolBar()->EnableTool(IDM_STOP, true);
|
||||
GetToolBar()->EnableTool(IDM_PLAY, true);
|
||||
|
||||
m_pMenuItemPlay->Enable(true);
|
||||
m_pMenuItemStop->Enable(true);
|
||||
m_pMenuItemLoad->Enable(true);
|
||||
m_pMenuItemSave->Enable(true);
|
||||
|
||||
if (Core::GetState() == Core::CORE_RUN)
|
||||
{
|
||||
GetToolBar()->SetToolNormalBitmap(IDM_PLAY, m_Bitmaps[Toolbar_Pause]);
|
||||
GetToolBar()->SetToolShortHelp(IDM_PLAY, _T("Pause"));
|
||||
|
||||
m_pMenuItemPlay->SetText(_T("Pause"));
|
||||
}
|
||||
else
|
||||
{
|
||||
GetToolBar()->SetToolNormalBitmap(IDM_PLAY, m_Bitmaps[Toolbar_Play]);
|
||||
GetToolBar()->SetToolShortHelp(IDM_PLAY, _T("Play"));
|
||||
|
||||
m_pMenuItemPlay->SetText(_T("Play"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// gamelistctrl
|
||||
{
|
||||
if (Core::GetState() == Core::CORE_UNINITIALIZED)
|
||||
{
|
||||
if (m_GameListCtrl && !m_GameListCtrl->IsShown())
|
||||
{
|
||||
m_GameListCtrl->Enable();
|
||||
m_GameListCtrl->Show();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (m_GameListCtrl && m_GameListCtrl->IsShown())
|
||||
{
|
||||
m_GameListCtrl->Disable();
|
||||
m_GameListCtrl->Hide();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
97
Source/Core/DolphinWX/Src/Frame.h
Normal file
97
Source/Core/DolphinWX/Src/Frame.h
Normal file
|
|
@ -0,0 +1,97 @@
|
|||
#ifndef __FRAME_H_
|
||||
#define __FRAME_H_
|
||||
|
||||
class CGameListCtrl;
|
||||
class CFrame
|
||||
: public wxFrame
|
||||
{
|
||||
public:
|
||||
|
||||
CFrame(wxFrame* parent,
|
||||
wxWindowID id = wxID_ANY,
|
||||
const wxString& title = _T("Dolphin"),
|
||||
const wxPoint& pos = wxDefaultPosition,
|
||||
const wxSize& size = wxDefaultSize,
|
||||
long style = wxDEFAULT_FRAME_STYLE | wxCLIP_CHILDREN | wxNO_FULL_REPAINT_ON_RESIZE);
|
||||
|
||||
void* GetRenderHandle() {return(m_Panel->GetHandle());}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
CGameListCtrl* m_GameListCtrl;
|
||||
wxPanel* m_Panel;
|
||||
|
||||
enum EBitmaps
|
||||
{
|
||||
Toolbar_FileOpen,
|
||||
Toolbar_Refresh,
|
||||
Toolbar_Browse,
|
||||
Toolbar_Play,
|
||||
Toolbar_Play_Dis,
|
||||
Toolbar_Stop,
|
||||
Toolbar_Stop_Dis,
|
||||
Toolbar_Pause,
|
||||
Toolbar_PluginOptions,
|
||||
Toolbar_PluginOptions_Dis,
|
||||
Toolbar_PluginGFX,
|
||||
Toolbar_PluginDSP,
|
||||
Toolbar_PluginPAD,
|
||||
Toolbar_FullScreen,
|
||||
Toolbar_Help,
|
||||
Bitmaps_Max
|
||||
};
|
||||
|
||||
wxBitmap m_Bitmaps[Bitmaps_Max];
|
||||
wxBitmap m_BitmapsMenu[Bitmaps_Max];
|
||||
|
||||
void InitBitmaps();
|
||||
void PopulateToolbar(wxToolBar* toolBar);
|
||||
void RecreateToolbar();
|
||||
void CreateMenu();
|
||||
|
||||
// event handler
|
||||
void OnQuit(wxCommandEvent& event);
|
||||
void OnHelp(wxCommandEvent& event);
|
||||
void OnRefresh(wxCommandEvent& event);
|
||||
void OnPluginOptions(wxCommandEvent& event);
|
||||
void OnPluginGFX(wxCommandEvent& event);
|
||||
void OnPluginDSP(wxCommandEvent& event);
|
||||
void OnPluginPAD(wxCommandEvent& event);
|
||||
void OnOpen(wxCommandEvent& event);
|
||||
void OnPlay(wxCommandEvent& event);
|
||||
void OnStop(wxCommandEvent& event);
|
||||
void OnBrowse(wxCommandEvent& event);
|
||||
void OnMemcard(wxCommandEvent& event);
|
||||
void OnToggleFullscreen(wxCommandEvent& event);
|
||||
void OnToggleDualCore(wxCommandEvent& event);
|
||||
void OnToggleThrottle(wxCommandEvent& event);
|
||||
void OnToggleToolbar(wxCommandEvent& event);
|
||||
void OnKeyDown(wxKeyEvent& event);
|
||||
void OnHostMessage(wxCommandEvent& event);
|
||||
void OnLoadState(wxCommandEvent& event);
|
||||
void OnSaveState(wxCommandEvent& event);
|
||||
|
||||
|
||||
wxStatusBar* m_pStatusBar;
|
||||
wxMenuBar* m_pMenuBar;
|
||||
|
||||
wxMenuItem* m_pMenuItemPlay;
|
||||
wxMenuItem* m_pMenuItemStop;
|
||||
wxMenuItem* m_pPluginOptions;
|
||||
|
||||
wxMenuItem* m_pMenuItemLoad;
|
||||
wxMenuItem* m_pMenuItemSave;
|
||||
|
||||
wxBusyInfo* m_pBootProcessDialog;
|
||||
|
||||
void UpdateGUI();
|
||||
|
||||
|
||||
// old function that could be cool
|
||||
|
||||
DECLARE_EVENT_TABLE();
|
||||
};
|
||||
|
||||
#endif // __FRAME_H_
|
||||
|
||||
491
Source/Core/DolphinWX/Src/GameListCtrl.cpp
Normal file
491
Source/Core/DolphinWX/Src/GameListCtrl.cpp
Normal file
|
|
@ -0,0 +1,491 @@
|
|||
// Copyright (C) 2003-2008 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 "Globals.h"
|
||||
|
||||
#include <wx/imaglist.h>
|
||||
#include <algorithm>
|
||||
|
||||
#include "FileSearch.h"
|
||||
#include "FileUtil.h"
|
||||
#include "StringUtil.h"
|
||||
#include "BootManager.h"
|
||||
#include "Config.h"
|
||||
#include "GameListCtrl.h"
|
||||
|
||||
|
||||
#if USE_XPM_BITMAPS
|
||||
#include "../resources/Flag_Europe.xpm"
|
||||
#include "../resources/Flag_France.xpm"
|
||||
#include "../resources/Flag_Japan.xpm"
|
||||
#include "../resources/Flag_USA.xpm"
|
||||
#endif // USE_XPM_BITMAPS
|
||||
|
||||
|
||||
BEGIN_EVENT_TABLE(CGameListCtrl, wxListCtrl)
|
||||
|
||||
EVT_SIZE(CGameListCtrl::OnSize)
|
||||
EVT_RIGHT_DOWN(CGameListCtrl::OnRightClick)
|
||||
EVT_LIST_COL_BEGIN_DRAG(LIST_CTRL, CGameListCtrl::OnColBeginDrag)
|
||||
EVT_LIST_ITEM_SELECTED(LIST_CTRL, CGameListCtrl::OnSelected)
|
||||
EVT_LIST_ITEM_ACTIVATED(LIST_CTRL, CGameListCtrl::OnActivated)
|
||||
EVT_LIST_COL_END_DRAG(LIST_CTRL, CGameListCtrl::OnColEndDrag)
|
||||
EVT_MENU(IDM_EDITPATCHFILE, CGameListCtrl::OnEditPatchFile)
|
||||
EVT_MENU(IDM_OPENCONTAININGFOLDER, CGameListCtrl::OnOpenContainingFolder)
|
||||
END_EVENT_TABLE()
|
||||
|
||||
|
||||
CGameListCtrl::CGameListCtrl(wxWindow* parent, const wxWindowID id, const wxPoint& pos, const wxSize& size, long style)
|
||||
: wxListCtrl(parent, id, pos, size, style) // | wxLC_VIRTUAL)
|
||||
{
|
||||
InitBitmaps();
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
CGameListCtrl::InitBitmaps()
|
||||
{
|
||||
m_imageListSmall = new wxImageList(96, 32);
|
||||
SetImageList(m_imageListSmall, wxIMAGE_LIST_SMALL);
|
||||
m_FlagImageIndex.resize(DiscIO::IVolume::NUMBER_OF_COUNTRIES);
|
||||
wxIcon iconTemp;
|
||||
iconTemp.CopyFromBitmap(wxBitmap(Flag_Europe_xpm));
|
||||
m_FlagImageIndex[DiscIO::IVolume::COUNTRY_EUROPE] = m_imageListSmall->Add(iconTemp);
|
||||
iconTemp.CopyFromBitmap(wxBitmap(Flag_France_xpm));
|
||||
m_FlagImageIndex[DiscIO::IVolume::COUNTRY_FRANCE] = m_imageListSmall->Add(iconTemp);
|
||||
iconTemp.CopyFromBitmap(wxBitmap(Flag_USA_xpm));
|
||||
m_FlagImageIndex[DiscIO::IVolume::COUNTRY_USA] = m_imageListSmall->Add(iconTemp);
|
||||
iconTemp.CopyFromBitmap(wxBitmap(Flag_Japan_xpm));
|
||||
m_FlagImageIndex[DiscIO::IVolume::COUNTRY_JAP] = m_imageListSmall->Add(iconTemp);
|
||||
iconTemp.CopyFromBitmap(wxBitmap(Flag_Europe_xpm));
|
||||
m_FlagImageIndex[DiscIO::IVolume::COUNTRY_UNKNOWN] = m_imageListSmall->Add(iconTemp);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
CGameListCtrl::BrowseForDirectory()
|
||||
{
|
||||
wxString dirHome;
|
||||
wxGetHomeDir(&dirHome);
|
||||
|
||||
// browse
|
||||
wxDirDialog dialog(this, _T("Browse directory"), dirHome, wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST);
|
||||
|
||||
if (dialog.ShowModal() == wxID_OK)
|
||||
{
|
||||
SConfig::GetInstance().m_ISOFolder.push_back(
|
||||
std::string(dialog.GetPath().ToAscii())
|
||||
);
|
||||
SConfig::GetInstance().SaveSettings();
|
||||
Update();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
CGameListCtrl::Update()
|
||||
{
|
||||
Hide();
|
||||
|
||||
ScanForISOs();
|
||||
|
||||
ClearAll();
|
||||
|
||||
if (m_ISOFiles.size() != 0)
|
||||
{
|
||||
// add columns
|
||||
InsertColumn(COLUMN_BANNER, _T("Banner"));
|
||||
InsertColumn(COLUMN_TITLE, _T("Title"));
|
||||
InsertColumn(COLUMN_COMPANY, _T("Company"));
|
||||
InsertColumn(COLUMN_COUNTRY, _T(""));
|
||||
InsertColumn(COLUMN_SIZE, _T("Size"));
|
||||
InsertColumn(COLUMN_EMULATION_STATE, _T("Emulation"), wxLIST_FORMAT_LEFT);
|
||||
|
||||
// add all items
|
||||
for (int i = 0; i < (int)m_ISOFiles.size(); i++)
|
||||
{
|
||||
InsertItemInReportView(i);
|
||||
}
|
||||
SetItemState(0, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
|
||||
}
|
||||
else
|
||||
{
|
||||
InsertColumn(COLUMN_BANNER, _T("No ISOs found"));
|
||||
|
||||
// data
|
||||
wxString buf(_T("Dolphin could not find any GC/Wii ISOs. Doubleclick here to browse for files..."));
|
||||
long item = InsertItem(0, buf, -1);
|
||||
SetItemFont(item, *wxITALIC_FONT);
|
||||
SetColumnWidth(item, wxLIST_AUTOSIZE);
|
||||
SetItemState(0, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
|
||||
}
|
||||
|
||||
AutomaticColumnWidth();
|
||||
|
||||
Show();
|
||||
}
|
||||
|
||||
#ifdef _WIN32
|
||||
wxColour blend50(const wxColour& c1, const wxColour& c2)
|
||||
{
|
||||
return(((c1.GetPixel() & 0xFEFEFE) >> 1) + ((c2.GetPixel() & 0xFEFEFE) >> 1) + 0x010101);
|
||||
}
|
||||
#endif
|
||||
|
||||
wxString NiceSizeFormat(s64 _size)
|
||||
{
|
||||
const char* sizes[] = {"b", "KB", "MB", "GB", "TB", "PB", "EB"};
|
||||
int s = 0;
|
||||
int frac = 0;
|
||||
|
||||
while (_size > (s64)1024)
|
||||
{
|
||||
s++;
|
||||
frac = (int)_size & 1023;
|
||||
_size /= (s64)1024;
|
||||
}
|
||||
|
||||
float f = (float)_size + ((float)frac / 1024.0f);
|
||||
|
||||
wxString NiceString;
|
||||
char tempstr[32];
|
||||
sprintf(tempstr,"%3.1f %s", f, sizes[s]);
|
||||
NiceString = wxString::FromAscii(tempstr);
|
||||
return(NiceString);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
CGameListCtrl::InsertItemInReportView(size_t _Index)
|
||||
{
|
||||
CISOFile& rISOFile = m_ISOFiles[_Index];
|
||||
|
||||
int ImageIndex = -1;
|
||||
|
||||
if (rISOFile.GetImage().IsOk())
|
||||
{
|
||||
ImageIndex = m_imageListSmall->Add(rISOFile.GetImage());
|
||||
}
|
||||
|
||||
// data
|
||||
wxString buf;
|
||||
long ItemIndex = InsertItem(_Index, buf, ImageIndex);
|
||||
#ifdef _WIN32
|
||||
wxColour color = (_Index & 1) ? blend50(GetSysColor(COLOR_3DLIGHT), GetSysColor(COLOR_WINDOW)) : GetSysColor(COLOR_WINDOW);
|
||||
#else
|
||||
wxColour color = (_Index & 1) ? 0xFFFFFF : 0xEEEEEE;
|
||||
#endif
|
||||
// background color color
|
||||
{
|
||||
wxListItem item;
|
||||
item.SetId(ItemIndex);
|
||||
item.SetBackgroundColour(color);
|
||||
SetItem(item);
|
||||
}
|
||||
|
||||
// title color
|
||||
{
|
||||
wxListItem item;
|
||||
item.SetId(ItemIndex);
|
||||
item.SetColumn(COLUMN_TITLE);
|
||||
item.SetText(wxString::FromAscii(rISOFile.GetName().c_str()));
|
||||
SetItem(item);
|
||||
}
|
||||
|
||||
// company color
|
||||
{
|
||||
wxListItem item;
|
||||
item.SetId(ItemIndex);
|
||||
item.SetColumn(COLUMN_COMPANY);
|
||||
item.SetText(wxString::FromAscii(rISOFile.GetCompany().c_str()));
|
||||
SetItem(item);
|
||||
}
|
||||
|
||||
// size
|
||||
{
|
||||
wxListItem item;
|
||||
item.SetId(ItemIndex);
|
||||
item.SetColumn(COLUMN_SIZE);
|
||||
item.SetText(NiceSizeFormat(rISOFile.GetFileSize()));
|
||||
SetItem(item);
|
||||
}
|
||||
|
||||
#ifndef __WXMSW__
|
||||
// country
|
||||
{
|
||||
// Can't do this in Windows - we use DrawSubItem instead, see below
|
||||
wxListItem item;
|
||||
item.m_itemId = ItemIndex;
|
||||
item.SetColumn(COLUMN_COUNTRY);
|
||||
item.SetBackgroundColour(color);
|
||||
DiscIO::IVolume::ECountry Country = rISOFile.GetCountry();
|
||||
|
||||
if (size_t(Country) < m_FlagImageIndex.size())
|
||||
{
|
||||
item.SetImage(m_FlagImageIndex[rISOFile.GetCountry()]);
|
||||
}
|
||||
|
||||
SetItem(item);
|
||||
}
|
||||
#endif // __WXMSW__
|
||||
|
||||
// item data
|
||||
SetItemData(ItemIndex, _Index);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
CGameListCtrl::ScanForISOs()
|
||||
{
|
||||
m_ISOFiles.clear();
|
||||
|
||||
CFileSearch::XStringVector Directories(SConfig::GetInstance().m_ISOFolder);
|
||||
|
||||
CFileSearch::XStringVector Extensions;
|
||||
Extensions.push_back("*.iso");
|
||||
Extensions.push_back("*.gcm");
|
||||
Extensions.push_back("*.gcz");
|
||||
|
||||
CFileSearch FileSearch(Extensions, Directories);
|
||||
const CFileSearch::XStringVector& rFilenames = FileSearch.GetFileNames();
|
||||
|
||||
if (rFilenames.size() > 0)
|
||||
{
|
||||
wxProgressDialog dialog(_T("Scanning for ISOs"),
|
||||
_T("Scanning..."),
|
||||
rFilenames.size(), // range
|
||||
this, // parent
|
||||
wxPD_CAN_ABORT |
|
||||
wxPD_APP_MODAL |
|
||||
// wxPD_AUTO_HIDE | -- try this as well
|
||||
wxPD_ELAPSED_TIME |
|
||||
wxPD_ESTIMATED_TIME |
|
||||
wxPD_REMAINING_TIME |
|
||||
wxPD_SMOOTH // - makes indeterminate mode bar on WinXP very small
|
||||
);
|
||||
|
||||
dialog.CenterOnParent();
|
||||
|
||||
for (size_t i = 0; i < rFilenames.size(); i++)
|
||||
{
|
||||
std::string FileName;
|
||||
SplitPath(rFilenames[i], NULL, &FileName, NULL);
|
||||
|
||||
wxString msg;
|
||||
char tempstring[128];
|
||||
sprintf(tempstring,"Scanning %s", FileName.c_str());
|
||||
msg = wxString::FromAscii(tempstring);
|
||||
|
||||
bool Cont = dialog.Update(i, msg);
|
||||
|
||||
if (!Cont)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
CISOFile ISOFile(rFilenames[i]);
|
||||
|
||||
if (ISOFile.IsValid())
|
||||
{
|
||||
m_ISOFiles.push_back(ISOFile);
|
||||
}
|
||||
}
|
||||
}
|
||||
std::sort(m_ISOFiles.begin(), m_ISOFiles.end());
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
CGameListCtrl::OnColBeginDrag(wxListEvent& event)
|
||||
{
|
||||
event.Veto();
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
CGameListCtrl::OnColEndDrag(wxListEvent& WXUNUSED (event))
|
||||
{
|
||||
AutomaticColumnWidth();
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
CGameListCtrl::OnRightClick(wxMouseEvent& event)
|
||||
{
|
||||
// Focus the clicked item.
|
||||
int flags;
|
||||
long item = HitTest(event.GetPosition(), flags);
|
||||
if (item != wxNOT_FOUND) {
|
||||
SetItemState(item, wxLIST_STATE_SELECTED | wxLIST_STATE_FOCUSED,
|
||||
wxLIST_STATE_SELECTED | wxLIST_STATE_FOCUSED);
|
||||
}
|
||||
const CISOFile *selected_iso = GetSelectedISO();
|
||||
if (selected_iso) {
|
||||
std::string unique_id = selected_iso->GetUniqueID();
|
||||
wxMenu popupMenu;
|
||||
std::string menu_text = StringFromFormat("Edit &patch file: %s.ini", unique_id.c_str());
|
||||
popupMenu.Append(IDM_EDITPATCHFILE, wxString::FromAscii(menu_text.c_str())); //Pretty much everything in wxwidgets is a wxString, try to convert to those first!
|
||||
popupMenu.Append(IDM_OPENCONTAININGFOLDER, wxString::FromAscii("Open &containing folder"));
|
||||
PopupMenu(&popupMenu);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
CGameListCtrl::OnActivated(wxListEvent& event)
|
||||
{
|
||||
if (m_ISOFiles.size() == 0)
|
||||
{
|
||||
BrowseForDirectory();
|
||||
}
|
||||
else
|
||||
{
|
||||
size_t Index = event.GetData();
|
||||
if (Index < m_ISOFiles.size())
|
||||
{
|
||||
const CISOFile& rISOFile = m_ISOFiles[Index];
|
||||
BootManager::BootCore(rISOFile.GetFileName());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const CISOFile *
|
||||
CGameListCtrl::GetSelectedISO() const
|
||||
{
|
||||
int item = GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
|
||||
if (item == -1)
|
||||
return 0;
|
||||
else
|
||||
return &m_ISOFiles[GetItemData(item)];
|
||||
}
|
||||
|
||||
void
|
||||
CGameListCtrl::OnOpenContainingFolder(wxCommandEvent& WXUNUSED (event)) {
|
||||
const CISOFile *iso = GetSelectedISO();
|
||||
if (!iso)
|
||||
return;
|
||||
std::string path;
|
||||
SplitPath(iso->GetFileName(), &path, 0, 0);
|
||||
File::Explore(path);
|
||||
}
|
||||
|
||||
void
|
||||
CGameListCtrl::OnEditPatchFile(wxCommandEvent& WXUNUSED (event))
|
||||
{
|
||||
const CISOFile *iso = GetSelectedISO();
|
||||
if (!iso)
|
||||
return;
|
||||
std::string filename = "Patches/" + iso->GetUniqueID() + ".ini";
|
||||
if (!File::Exists(filename)) {
|
||||
if (AskYesNo("%s.ini does not exist. Do you want to create it?", iso->GetUniqueID().c_str())) {
|
||||
FILE *f = fopen(filename.c_str(), "w");
|
||||
fprintf(f, "# %s - %s\r\n\r\n", iso->GetUniqueID().c_str(), iso->GetName().c_str());
|
||||
fprintf(f, "[OnFrame]\r\n#Add memory patches here.\r\n\r\n");
|
||||
fprintf(f, "[ActionReplay]\r\n#Add decrypted action replay cheats here.\r\n");
|
||||
fclose(f);
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
}
|
||||
File::Launch(filename);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
CGameListCtrl::OnSelected(wxListEvent& WXUNUSED (event))
|
||||
{}
|
||||
|
||||
|
||||
void CGameListCtrl::OnSize(wxSizeEvent& WXUNUSED (event))
|
||||
{
|
||||
AutomaticColumnWidth();
|
||||
}
|
||||
|
||||
|
||||
bool
|
||||
CGameListCtrl::MSWDrawSubItem(wxPaintDC& rPaintDC, int item, int subitem)
|
||||
{
|
||||
bool Result = false;
|
||||
#ifdef __WXMSW__
|
||||
switch (subitem)
|
||||
{
|
||||
case COLUMN_COUNTRY:
|
||||
{
|
||||
size_t Index = GetItemData(item);
|
||||
|
||||
if (Index < m_ISOFiles.size())
|
||||
{
|
||||
const CISOFile& rISO = m_ISOFiles[Index];
|
||||
wxRect SubItemRect;
|
||||
this->GetSubItemRect(item, subitem, SubItemRect);
|
||||
m_imageListSmall->Draw(m_FlagImageIndex[rISO.GetCountry()], rPaintDC, SubItemRect.GetLeft(), SubItemRect.GetTop());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
#endif
|
||||
|
||||
return(Result);
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
CGameListCtrl::AutomaticColumnWidth()
|
||||
{
|
||||
wxRect rc(GetClientRect());
|
||||
|
||||
if (GetColumnCount() == 1)
|
||||
{
|
||||
SetColumnWidth(0, rc.GetWidth());
|
||||
}
|
||||
else if (GetColumnCount() > 4)
|
||||
{
|
||||
SetColumnWidth(COLUMN_COUNTRY, 32);
|
||||
SetColumnWidth(COLUMN_BANNER, 106);
|
||||
|
||||
// width
|
||||
for (int i = 0; i < GetColumnCount() - 1; i++)
|
||||
{
|
||||
if ((i != COLUMN_COUNTRY) && (i != COLUMN_BANNER))
|
||||
{
|
||||
SetColumnWidth(i, wxLIST_AUTOSIZE);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int size = 0;
|
||||
|
||||
for (int i = 0; i < GetColumnCount() - 1; i++)
|
||||
{
|
||||
size += GetColumnWidth(i);
|
||||
}
|
||||
|
||||
int rest = rc.GetWidth() - size - 3;
|
||||
|
||||
if (rest > 0)
|
||||
{
|
||||
SetColumnWidth(GetColumnCount() - 1, rest);
|
||||
}
|
||||
else
|
||||
{
|
||||
SetColumnWidth(GetColumnCount() - 1, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
78
Source/Core/DolphinWX/Src/GameListCtrl.h
Normal file
78
Source/Core/DolphinWX/Src/GameListCtrl.h
Normal file
|
|
@ -0,0 +1,78 @@
|
|||
// Copyright (C) 2003-2008 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/
|
||||
|
||||
#ifndef __GAMELIST_CTRL_H_
|
||||
#define __GAMELIST_CTRL_H_
|
||||
|
||||
#include <vector>
|
||||
|
||||
#include <wx/listctrl.h>
|
||||
|
||||
#include "ISOFile.h"
|
||||
|
||||
class CGameListCtrl : public wxListCtrl
|
||||
{
|
||||
public:
|
||||
|
||||
CGameListCtrl(wxWindow* parent, const wxWindowID id, const wxPoint& pos, const wxSize& size, long style);
|
||||
void Update();
|
||||
void BrowseForDirectory();
|
||||
const CISOFile *GetSelectedISO() const;
|
||||
|
||||
private:
|
||||
|
||||
enum
|
||||
{
|
||||
COLUMN_BANNER = 0,
|
||||
COLUMN_TITLE,
|
||||
COLUMN_COMPANY,
|
||||
COLUMN_COUNTRY,
|
||||
COLUMN_SIZE,
|
||||
COLUMN_EMULATION_STATE,
|
||||
NUMBER_OF_COLUMN
|
||||
};
|
||||
|
||||
std::vector<int>m_FlagImageIndex;
|
||||
|
||||
bool m_test;
|
||||
std::vector<CISOFile> m_ISOFiles;
|
||||
|
||||
void InitBitmaps();
|
||||
void InsertItemInReportView(size_t _Index);
|
||||
void ScanForISOs();
|
||||
|
||||
DECLARE_EVENT_TABLE()
|
||||
|
||||
// events
|
||||
void OnRightClick(wxMouseEvent& event);
|
||||
|
||||
void OnColBeginDrag(wxListEvent& event);
|
||||
void OnColEndDrag(wxListEvent& event);
|
||||
void OnSelected(wxListEvent& event);
|
||||
void OnActivated(wxListEvent& event);
|
||||
void OnSize(wxSizeEvent& event);
|
||||
void OnEditPatchFile(wxCommandEvent& event);
|
||||
void OnOpenContainingFolder(wxCommandEvent& event);
|
||||
|
||||
virtual bool MSWDrawSubItem(wxPaintDC& rPaintDC, int item, int subitem);
|
||||
|
||||
void AutomaticColumnWidth();
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
18
Source/Core/DolphinWX/Src/Globals.cpp
Normal file
18
Source/Core/DolphinWX/Src/Globals.cpp
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
// Copyright (C) 2003-2008 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 "Globals.h"
|
||||
121
Source/Core/DolphinWX/Src/Globals.h
Normal file
121
Source/Core/DolphinWX/Src/Globals.h
Normal file
|
|
@ -0,0 +1,121 @@
|
|||
// Copyright (C) 2003-2008 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/
|
||||
|
||||
#ifndef _GLOBALS_H
|
||||
#define _GLOBALS_H
|
||||
|
||||
enum
|
||||
{
|
||||
IDM_LOADSTATE = 200,
|
||||
IDM_SAVESTATE,
|
||||
IDM_SAVESLOT1,
|
||||
IDM_SAVESLOT2,
|
||||
IDM_SAVESLOT3,
|
||||
IDM_SAVESLOT4,
|
||||
IDM_SAVESLOT5,
|
||||
IDM_SAVESLOT6,
|
||||
IDM_SAVESLOT7,
|
||||
IDM_SAVESLOT8,
|
||||
IDM_SAVESLOT9,
|
||||
IDM_SAVESLOT10,
|
||||
IDM_LOADSLOT1,
|
||||
IDM_LOADSLOT2,
|
||||
IDM_LOADSLOT3,
|
||||
IDM_LOADSLOT4,
|
||||
IDM_LOADSLOT5,
|
||||
IDM_LOADSLOT6,
|
||||
IDM_LOADSLOT7,
|
||||
IDM_LOADSLOT8,
|
||||
IDM_LOADSLOT9,
|
||||
IDM_LOADSLOT10,
|
||||
IDM_PLAY,
|
||||
IDM_STOP,
|
||||
IDM_BROWSE,
|
||||
IDM_MEMCARD,
|
||||
IDM_EDITPATCHFILE,
|
||||
IDM_OPENCONTAININGFOLDER,
|
||||
IDM_PLUGIN_OPTIONS,
|
||||
IDM_CONFIG_GFX_PLUGIN,
|
||||
IDM_CONFIG_DSP_PLUGIN,
|
||||
IDM_CONFIG_PAD_PLUGIN,
|
||||
IDM_TOGGLE_FULLSCREEN,
|
||||
IDM_TOGGLE_DUALCORE,
|
||||
IDM_TOGGLE_TOOLBAR,
|
||||
IDM_NOTIFYMAPLOADED,
|
||||
IDM_UPDATELOGDISPLAY,
|
||||
IDM_UPDATEDISASMDIALOG,
|
||||
IDM_UPDATEGUI,
|
||||
IDM_UPDATESTATUSBAR,
|
||||
IDM_UPDATEBREAKPOINTS,
|
||||
IDM_HOST_MESSAGE,
|
||||
IDM_BOOTING_STARTED,
|
||||
IDM_BOOTING_ENDED,
|
||||
IDM_HELPABOUT,
|
||||
IDM_HELPWEBSITE,
|
||||
IDM_HELPGOOGLECODE,
|
||||
ID_TOOLBAR = 500,
|
||||
LIST_CTRL = 1000
|
||||
};
|
||||
|
||||
#define wxUSE_XPM_IN_MSW 1
|
||||
#define USE_XPM_BITMAPS 1
|
||||
|
||||
// For compilers that support precompilation, includes <wx/wx.h>.
|
||||
//#include <wx/wxprec.h>
|
||||
|
||||
//#ifndef WX_PRECOMP
|
||||
#include <wx/wx.h>
|
||||
//#endif
|
||||
|
||||
#include <wx/toolbar.h>
|
||||
#include <wx/log.h>
|
||||
#include <wx/image.h>
|
||||
#include <wx/aboutdlg.h>
|
||||
#include <wx/filedlg.h>
|
||||
#include <wx/spinctrl.h>
|
||||
#include <wx/srchctrl.h>
|
||||
#include <wx/listctrl.h>
|
||||
#include <wx/progdlg.h>
|
||||
#include <wx/imagpng.h>
|
||||
#include <wx/button.h>
|
||||
#include <wx/stattext.h>
|
||||
#include <wx/choice.h>
|
||||
#include <wx/cmdline.h>
|
||||
#include <wx/busyinfo.h>
|
||||
|
||||
// define this to use XPMs everywhere (by default, BMPs are used under Win)
|
||||
// BMPs use less space, but aren't compiled into the executable on other platforms
|
||||
|
||||
#if USE_XPM_BITMAPS && defined (__WXMSW__) && !wxUSE_XPM_IN_MSW
|
||||
#error You need to enable XPM support to use XPM bitmaps with toolbar!
|
||||
#endif // USE_XPM_BITMAPS
|
||||
|
||||
|
||||
//
|
||||
// custom message macro
|
||||
//
|
||||
|
||||
#define EVT_HOST_COMMAND(id, fn) \
|
||||
DECLARE_EVENT_TABLE_ENTRY(\
|
||||
wxEVT_HOST_COMMAND, id, wxID_ANY, \
|
||||
(wxObjectEventFunction)(wxEventFunction) wxStaticCastEvent(wxCommandEventFunction, &fn), \
|
||||
(wxObject*) NULL \
|
||||
),
|
||||
|
||||
extern const wxEventType wxEVT_HOST_COMMAND;
|
||||
|
||||
#endif
|
||||
98
Source/Core/DolphinWX/Src/ISOFile.cpp
Normal file
98
Source/Core/DolphinWX/Src/ISOFile.cpp
Normal file
|
|
@ -0,0 +1,98 @@
|
|||
// Copyright (C) 2003-2008 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 <string>
|
||||
#include <vector>
|
||||
|
||||
#include "Globals.h"
|
||||
#include "ISOFile.h"
|
||||
|
||||
#include "VolumeCreator.h"
|
||||
#include "Filesystem.h"
|
||||
#include "BannerLoader.h"
|
||||
#include "FileSearch.h"
|
||||
|
||||
#define DVD_BANNER_WIDTH 96
|
||||
#define DVD_BANNER_HEIGHT 32
|
||||
|
||||
static u32 g_ImageTemp[DVD_BANNER_WIDTH * DVD_BANNER_HEIGHT];
|
||||
|
||||
CISOFile::CISOFile(const std::string& _rFileName)
|
||||
: m_FileName(_rFileName),
|
||||
m_FileSize(0),
|
||||
m_Valid(false)
|
||||
{
|
||||
DiscIO::IVolume* pVolume = DiscIO::CreateVolumeFromFilename(_rFileName);
|
||||
|
||||
if (pVolume != NULL)
|
||||
{
|
||||
m_Name = _rFileName;
|
||||
m_Country = pVolume->GetCountry();
|
||||
m_FileSize = pVolume->GetSize();
|
||||
m_Name = pVolume->GetName();
|
||||
m_UniqueID = pVolume->GetUniqueID();
|
||||
|
||||
// check if we can get some infos from the banner file too
|
||||
DiscIO::IFileSystem* pFileSystem = DiscIO::CreateFileSystem(*pVolume);
|
||||
|
||||
if (pFileSystem != NULL)
|
||||
{
|
||||
DiscIO::IBannerLoader* pBannerLoader = DiscIO::CreateBannerLoader(*pFileSystem);
|
||||
|
||||
if (pBannerLoader != NULL)
|
||||
{
|
||||
if (pBannerLoader->IsValid())
|
||||
{
|
||||
pBannerLoader->GetName(m_Name, 0); //m_Country == DiscIO::IVolume::COUNTRY_JAP ? 1 : 0);
|
||||
pBannerLoader->GetCompany(m_Company);
|
||||
|
||||
if (pBannerLoader->GetBanner(g_ImageTemp))
|
||||
{
|
||||
unsigned char* pImage = (unsigned char*)malloc(DVD_BANNER_WIDTH * DVD_BANNER_HEIGHT * 3);
|
||||
|
||||
for (size_t i = 0; i < DVD_BANNER_WIDTH * DVD_BANNER_HEIGHT; i++)
|
||||
{
|
||||
pImage[i * 3 + 0] = (g_ImageTemp[i] & 0xFF0000) >> 16;
|
||||
pImage[i * 3 + 1] = (g_ImageTemp[i] & 0x00FF00) >> 8;
|
||||
pImage[i * 3 + 2] = (g_ImageTemp[i] & 0x0000FF) >> 0;
|
||||
}
|
||||
|
||||
m_Image.Create(DVD_BANNER_WIDTH, DVD_BANNER_HEIGHT, pImage);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// default banner
|
||||
}
|
||||
|
||||
delete pBannerLoader;
|
||||
}
|
||||
|
||||
delete pFileSystem;
|
||||
}
|
||||
|
||||
delete pVolume;
|
||||
|
||||
m_Valid = true;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
CISOFile::~CISOFile()
|
||||
{}
|
||||
|
||||
|
||||
68
Source/Core/DolphinWX/Src/ISOFile.h
Normal file
68
Source/Core/DolphinWX/Src/ISOFile.h
Normal file
|
|
@ -0,0 +1,68 @@
|
|||
// Copyright (C) 2003-2008 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/
|
||||
|
||||
#ifndef __ISOFILE_H_
|
||||
#define __ISOFILE_H_
|
||||
|
||||
#include "Volume.h"
|
||||
|
||||
class CISOFile
|
||||
{
|
||||
public:
|
||||
|
||||
CISOFile(const std::string& _rFileName);
|
||||
~CISOFile();
|
||||
|
||||
bool IsValid() const {return(m_Valid);}
|
||||
|
||||
const std::string& GetFileName() const {return(m_FileName);}
|
||||
|
||||
const std::string& GetName() const {return(m_Name);}
|
||||
|
||||
const std::string& GetCompany() const {return(m_Company);}
|
||||
|
||||
const std::string& GetUniqueID() const {return(m_UniqueID);}
|
||||
|
||||
DiscIO::IVolume::ECountry GetCountry() const {return(m_Country);}
|
||||
|
||||
u64 GetFileSize() const {return(m_FileSize);}
|
||||
|
||||
const wxImage& GetImage() const {return(m_Image);}
|
||||
|
||||
bool operator < (const CISOFile &other) const {
|
||||
// HACK - they end up in reverse order in the list view
|
||||
return strcmp(m_Name.c_str(), other.m_Name.c_str()) > 0;
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
std::string m_FileName;
|
||||
std::string m_Name;
|
||||
std::string m_Company;
|
||||
std::string m_UniqueID;
|
||||
|
||||
u64 m_FileSize;
|
||||
|
||||
DiscIO::IVolume::ECountry m_Country;
|
||||
|
||||
wxImage m_Image;
|
||||
|
||||
bool m_Valid;
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
276
Source/Core/DolphinWX/Src/Main.cpp
Normal file
276
Source/Core/DolphinWX/Src/Main.cpp
Normal file
|
|
@ -0,0 +1,276 @@
|
|||
// Copyright (C) 2003-2008 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 <vector>
|
||||
#include <string>
|
||||
#ifdef WIN32
|
||||
#include "svnrev.h"
|
||||
#endif
|
||||
#include "CPUDetect.h"
|
||||
#include "Globals.h"
|
||||
#include "Common.h"
|
||||
#include "IniFile.h"
|
||||
#include "Main.h"
|
||||
#include "Frame.h"
|
||||
#include "Config.h"
|
||||
#include "CodeWindow.h"
|
||||
#include "ExtendedTrace.h"
|
||||
|
||||
IMPLEMENT_APP(DolphinApp)
|
||||
|
||||
CFrame* main_frame = NULL;
|
||||
CCodeWindow* g_pCodeWindow = NULL;
|
||||
|
||||
#ifdef WIN32
|
||||
//Has no error handling.
|
||||
//I think that if an error occurs here there's no way to handle it anyway.
|
||||
LONG WINAPI MyUnhandledExceptionFilter(LPEXCEPTION_POINTERS e) {
|
||||
//EnterCriticalSection(&g_uefcs);
|
||||
|
||||
FILE* file=NULL;
|
||||
fopen_s(&file, "exceptioninfo.txt", "a");
|
||||
fseek(file, 0, SEEK_END);
|
||||
etfprint(file, "\n");
|
||||
//etfprint(file, g_buildtime);
|
||||
//etfprint(file, "\n");
|
||||
//dumpCurrentDate(file);
|
||||
etfprintf(file, "Unhandled Exception\n Code: 0x%08X\n",
|
||||
e->ExceptionRecord->ExceptionCode);
|
||||
#ifndef _M_X64
|
||||
STACKTRACE2(file, e->ContextRecord->Eip, e->ContextRecord->Esp, e->ContextRecord->Ebp);
|
||||
#else
|
||||
STACKTRACE2(file, e->ContextRecord->Rip, e->ContextRecord->Rsp, e->ContextRecord->Rbp);
|
||||
#endif
|
||||
fclose(file);
|
||||
_flushall();
|
||||
|
||||
//LeaveCriticalSection(&g_uefcs);
|
||||
return EXCEPTION_CONTINUE_SEARCH;
|
||||
}
|
||||
#endif
|
||||
|
||||
// The `main program' equivalent, creating the windows and returning the
|
||||
// main frame
|
||||
bool DolphinApp::OnInit()
|
||||
{
|
||||
DetectCPU();
|
||||
#ifndef _WIN32
|
||||
// RegisterPanicAlertHandler(&wxPanicAlert);
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
EXTENDEDTRACEINITIALIZE(".");
|
||||
SetUnhandledExceptionFilter(&MyUnhandledExceptionFilter);
|
||||
|
||||
// TODO: if First Boot
|
||||
if (!cpu_info.bSSE2)
|
||||
{
|
||||
MessageBox(0, _T("Hi,\n\nDolphin requires that your CPU has support for SSE2 extensions.\n"
|
||||
"Unfortunately your CPU does not support them, so Dolphin will not run.\n\n"
|
||||
"Sayonara!\n"), "Dolphin", MB_ICONINFORMATION);
|
||||
return false;
|
||||
}
|
||||
#else
|
||||
if (!cpu_info.bSSE2)
|
||||
{
|
||||
printf("%s", "Hi,\n\nDolphin requires that your CPU has support for SSE2 extensions.\n"
|
||||
"Unfortunately your CPU does not support them, so Dolphin will not run.\n\n"
|
||||
"Sayonara!\n");
|
||||
exit(0);
|
||||
}
|
||||
#endif
|
||||
|
||||
bool UseDebugger = false;
|
||||
|
||||
#if wxUSE_CMDLINE_PARSER
|
||||
wxCmdLineEntryDesc cmdLineDesc[] =
|
||||
{
|
||||
{wxCMD_LINE_SWITCH, _T("h"), _T("help"), _T("Show this help message"), wxCMD_LINE_VAL_NONE, wxCMD_LINE_OPTION_HELP},
|
||||
{wxCMD_LINE_SWITCH, _T("d"), _T("debugger"), _T("Opens the debugger")},
|
||||
{wxCMD_LINE_NONE}
|
||||
};
|
||||
|
||||
//gets the passed media files from command line
|
||||
wxCmdLineParser parser(cmdLineDesc, argc, argv);
|
||||
|
||||
// get filenames from the command line
|
||||
if (parser.Parse() != 0)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
UseDebugger = parser.Found(_T("debugger"));
|
||||
#endif
|
||||
|
||||
SConfig::GetInstance().LoadSettings();
|
||||
wxInitAllImageHandlers();
|
||||
// Create the main frame window
|
||||
#ifdef _WIN32
|
||||
#ifdef _DEBUG
|
||||
const char *title = "Dolphin Debug SVN R " SVN_REV_STR;
|
||||
#else
|
||||
const char *title = "Dolphin SVN R " SVN_REV_STR;
|
||||
#endif
|
||||
#else
|
||||
#ifdef _DEBUG
|
||||
const char *title = "Dolphin Debug SVN Linux";
|
||||
#else
|
||||
const char *title = "Dolphin SVN Linux";
|
||||
#endif
|
||||
#endif
|
||||
main_frame = new CFrame((wxFrame*) NULL, wxID_ANY, wxString::FromAscii(title),
|
||||
wxPoint(100, 100), wxSize(800, 600));
|
||||
|
||||
// create debugger
|
||||
if (UseDebugger)
|
||||
{
|
||||
g_pCodeWindow = new CCodeWindow(SConfig::GetInstance().m_LocalCoreStartupParameter, main_frame);
|
||||
g_pCodeWindow->Show(true);
|
||||
}
|
||||
|
||||
SetTopWindow(main_frame);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
void DolphinApp::OnEndSession()
|
||||
{
|
||||
SConfig::GetInstance().SaveSettings();
|
||||
}
|
||||
|
||||
|
||||
bool wxPanicAlert(const char* text, bool /*yes_no*/)
|
||||
{
|
||||
wxMessageBox(wxString::FromAscii(text), _T("PANIC ALERT"));
|
||||
return(true);
|
||||
}
|
||||
|
||||
|
||||
void Host_BootingStarted()
|
||||
{
|
||||
wxCommandEvent event(wxEVT_HOST_COMMAND, IDM_BOOTING_STARTED);
|
||||
wxPostEvent(main_frame, event);
|
||||
|
||||
if (g_pCodeWindow)
|
||||
{
|
||||
wxPostEvent(g_pCodeWindow, event);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void Host_BootingEnded()
|
||||
{
|
||||
wxCommandEvent event(wxEVT_HOST_COMMAND, IDM_BOOTING_ENDED);
|
||||
wxPostEvent(main_frame, event);
|
||||
|
||||
if (g_pCodeWindow)
|
||||
{
|
||||
wxPostEvent(g_pCodeWindow, event);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// OK, this thread boundary is DANGEROUS on linux
|
||||
// wxPostEvent / wxAddPendingEvent is the solution.
|
||||
void Host_NotifyMapLoaded()
|
||||
{
|
||||
wxCommandEvent event(wxEVT_HOST_COMMAND, IDM_NOTIFYMAPLOADED);
|
||||
wxPostEvent(main_frame, event);
|
||||
|
||||
if (g_pCodeWindow)
|
||||
{
|
||||
wxPostEvent(g_pCodeWindow, event);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void Host_UpdateLogDisplay()
|
||||
{
|
||||
wxCommandEvent event(wxEVT_HOST_COMMAND, IDM_UPDATELOGDISPLAY);
|
||||
wxPostEvent(main_frame, event);
|
||||
|
||||
if (g_pCodeWindow)
|
||||
{
|
||||
wxPostEvent(g_pCodeWindow, event);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void Host_UpdateDisasmDialog()
|
||||
{
|
||||
wxCommandEvent event(wxEVT_HOST_COMMAND, IDM_UPDATEDISASMDIALOG);
|
||||
wxPostEvent(main_frame, event);
|
||||
if (g_pCodeWindow)
|
||||
{
|
||||
wxPostEvent(g_pCodeWindow, event);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void Host_UpdateMainFrame()
|
||||
{
|
||||
wxCommandEvent event(wxEVT_HOST_COMMAND, IDM_UPDATEGUI);
|
||||
wxPostEvent(main_frame, event);
|
||||
|
||||
if (g_pCodeWindow)
|
||||
{
|
||||
wxPostEvent(g_pCodeWindow, event);
|
||||
}
|
||||
}
|
||||
|
||||
void Host_UpdateBreakPointView()
|
||||
{
|
||||
wxCommandEvent event(wxEVT_HOST_COMMAND, IDM_UPDATEBREAKPOINTS);
|
||||
wxPostEvent(main_frame, event);
|
||||
|
||||
if (g_pCodeWindow)
|
||||
{
|
||||
wxPostEvent(g_pCodeWindow, event);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void Host_UpdateMemoryView()
|
||||
{}
|
||||
|
||||
|
||||
void Host_SetDebugMode(bool)
|
||||
{}
|
||||
|
||||
|
||||
void Host_SetWaitCursor(bool enable)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
if (enable)
|
||||
{
|
||||
SetCursor(LoadCursor(NULL, IDC_WAIT));
|
||||
}
|
||||
else
|
||||
{
|
||||
SetCursor(LoadCursor(NULL, IDC_ARROW));
|
||||
}
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
void Host_UpdateStatusBar(const char* _pText)
|
||||
{
|
||||
wxCommandEvent event(wxEVT_HOST_COMMAND, IDM_UPDATESTATUSBAR);
|
||||
event.SetString(wxString::FromAscii(_pText));
|
||||
|
||||
wxPostEvent(main_frame, event);
|
||||
}
|
||||
32
Source/Core/DolphinWX/Src/Main.h
Normal file
32
Source/Core/DolphinWX/Src/Main.h
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
// Copyright (C) 2003-2008 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/
|
||||
|
||||
#ifndef __MAIN_H_
|
||||
#define __MAIN_H_
|
||||
|
||||
// Define a new application
|
||||
class DolphinApp
|
||||
: public wxApp
|
||||
{
|
||||
public:
|
||||
|
||||
bool OnInit();
|
||||
void OnEndSession();
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
89
Source/Core/DolphinWX/Src/MainNoGUI.cpp
Normal file
89
Source/Core/DolphinWX/Src/MainNoGUI.cpp
Normal file
|
|
@ -0,0 +1,89 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifndef _WIN32
|
||||
//#include <curses.h>
|
||||
#else
|
||||
#endif
|
||||
|
||||
#include "Globals.h"
|
||||
#include "Common.h"
|
||||
#include "ISOFile.h"
|
||||
#include "CPUDetect.h"
|
||||
|
||||
#include "BootManager.h"
|
||||
void* g_pCodeWindow = NULL;
|
||||
void* main_frame = NULL;
|
||||
bool wxPanicAlert(const char* text, bool /*yes_no*/)
|
||||
{
|
||||
return(true);
|
||||
}
|
||||
|
||||
|
||||
void Host_BootingStarted(){}
|
||||
|
||||
|
||||
void Host_BootingEnded(){}
|
||||
|
||||
|
||||
// OK, this thread boundary is DANGEROUS on linux
|
||||
// wxPostEvent / wxAddPendingEvent is the solution.
|
||||
void Host_NotifyMapLoaded(){}
|
||||
|
||||
|
||||
void Host_UpdateLogDisplay(){}
|
||||
|
||||
|
||||
void Host_UpdateDisasmDialog(){}
|
||||
|
||||
|
||||
void Host_UpdateMainFrame(){}
|
||||
|
||||
void Host_UpdateBreakPointView(){}
|
||||
|
||||
|
||||
void Host_UpdateMemoryView(){}
|
||||
|
||||
|
||||
void Host_SetDebugMode(bool){}
|
||||
|
||||
|
||||
void Host_SetWaitCursor(bool enable){}
|
||||
|
||||
|
||||
void Host_CreateDisplay(){}
|
||||
|
||||
|
||||
void Host_CloseDisplay(){}
|
||||
|
||||
void Host_UpdateStatusBar(const char* _pText){}
|
||||
|
||||
// Include SDL header so it can hijack main().
|
||||
#include <SDL.h>
|
||||
#include "cmdline.h"
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
gengetopt_args_info args_info;
|
||||
|
||||
if (cmdline_parser (argc, argv, &args_info) != 0)
|
||||
return(1);
|
||||
|
||||
if (args_info.inputs_num < 1)
|
||||
{
|
||||
fprintf(stderr, "Please supply at least one argument - the ISO to boot.\n");
|
||||
return(1);
|
||||
}
|
||||
std::string bootFile(args_info.inputs[0]);
|
||||
|
||||
DetectCPU();
|
||||
BootManager::BootCore(bootFile);
|
||||
usleep(2000 * 1000 * 1000);
|
||||
// while (!getch()) {
|
||||
// usleep(20);
|
||||
// }
|
||||
|
||||
cmdline_parser_free (&args_info);
|
||||
return(0);
|
||||
}
|
||||
|
||||
|
||||
313
Source/Core/DolphinWX/Src/MemcardManager.cpp
Normal file
313
Source/Core/DolphinWX/Src/MemcardManager.cpp
Normal file
|
|
@ -0,0 +1,313 @@
|
|||
// Copyright (C) 2003-2008 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 "Globals.h"
|
||||
|
||||
#include "MemcardManager.h"
|
||||
|
||||
#include "wx/mstream.h"
|
||||
|
||||
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_CLOSE(CMemcardManager::OnClose)
|
||||
EVT_BUTTON(ID_COPYRIGHT,CMemcardManager::CopyDeleteClick)
|
||||
EVT_BUTTON(ID_COPYLEFT,CMemcardManager::CopyDeleteClick)
|
||||
EVT_BUTTON(ID_DELETERIGHT,CMemcardManager::CopyDeleteClick)
|
||||
EVT_BUTTON(ID_DELETELEFT,CMemcardManager::CopyDeleteClick)
|
||||
EVT_FILEPICKER_CHANGED(ID_MEMCARD1PATH,CMemcardManager::OnPathChange)
|
||||
EVT_FILEPICKER_CHANGED(ID_MEMCARD2PATH,CMemcardManager::OnPathChange)
|
||||
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[0]=NULL;
|
||||
memoryCard[1]=NULL;
|
||||
CreateGUIControls();
|
||||
}
|
||||
|
||||
CMemcardManager::~CMemcardManager()
|
||||
{
|
||||
if (memoryCard[0]) {
|
||||
delete memoryCard[0];
|
||||
memoryCard[0] = NULL;
|
||||
}
|
||||
if (memoryCard[1]) {
|
||||
delete memoryCard[1];
|
||||
memoryCard[1] = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void CMemcardManager::CreateGUIControls()
|
||||
{
|
||||
// buttons
|
||||
m_CopyRight = new wxButton(this, ID_COPYRIGHT, wxT("->Copy->"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
|
||||
m_CopyLeft = new wxButton(this, ID_COPYLEFT, wxT("<-Copy<-"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
|
||||
|
||||
m_DeleteRight = new wxButton(this, ID_DELETERIGHT, wxT("Delete->"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
|
||||
m_DeleteLeft = new wxButton(this, ID_DELETELEFT, wxT("<-Delete"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
|
||||
|
||||
// sizers that double as wxStaticBoxes
|
||||
sMemcard1 = new wxStaticBoxSizer(wxVERTICAL, this, wxT("Memory Card 1"));
|
||||
sMemcard2 = new wxStaticBoxSizer(wxVERTICAL, this, wxT("Memory Card 2"));
|
||||
|
||||
// create the controls for both memcards
|
||||
// will change Mem*.raw to *.raw, when loading invalid .raw files doesn't crash the app :/
|
||||
m_Memcard1Path = new wxFilePickerCtrl(this, ID_MEMCARD1PATH, wxEmptyString, wxT("Choose a memory card:"),
|
||||
wxT("Dolphin memcards (Mem*.raw)|Mem*.raw"), wxDefaultPosition, wxDefaultSize, wxFLP_USE_TEXTCTRL|wxFLP_FILE_MUST_EXIST|wxFLP_OPEN);
|
||||
m_Memcard2Path = new wxFilePickerCtrl(this, ID_MEMCARD2PATH, wxEmptyString, wxT("Choose a memory card:"),
|
||||
wxT("Dolphin memcards (Mem*.raw)|Mem*.raw"), wxDefaultPosition, wxDefaultSize, wxFLP_USE_TEXTCTRL|wxFLP_FILE_MUST_EXIST|wxFLP_OPEN);
|
||||
|
||||
m_MemcardList[0] = new wxListCtrl(this, ID_MEMCARD1LIST, wxDefaultPosition, wxSize(350,400),
|
||||
wxLC_REPORT | wxSUNKEN_BORDER | wxLC_ALIGN_LEFT | wxLC_SINGLE_SEL);
|
||||
m_MemcardList[1] = new wxListCtrl(this, ID_MEMCARD2LIST, wxDefaultPosition, wxSize(350,400),
|
||||
wxLC_REPORT | wxSUNKEN_BORDER | wxLC_ALIGN_LEFT | wxLC_SINGLE_SEL);
|
||||
|
||||
m_MemcardList[0]->AssignImageList(new wxImageList(96,32),wxIMAGE_LIST_SMALL);
|
||||
m_MemcardList[1]->AssignImageList(new wxImageList(96,32),wxIMAGE_LIST_SMALL);
|
||||
|
||||
// mmmm sizer goodness
|
||||
wxBoxSizer* sButtons;
|
||||
sButtons = new wxBoxSizer(wxVERTICAL);
|
||||
sButtons->AddStretchSpacer(1);
|
||||
sButtons->Add(m_CopyRight, 0, 0, 5);
|
||||
sButtons->Add(m_CopyLeft, 0, 0, 5);
|
||||
sButtons->AddStretchSpacer(2);
|
||||
sButtons->Add(m_DeleteRight, 0, 0, 5);
|
||||
sButtons->Add(m_DeleteLeft, 0, 0, 5);
|
||||
sButtons->AddStretchSpacer(1);
|
||||
|
||||
sMemcard1->Add(m_Memcard1Path, 0, wxEXPAND|wxALL, 5);
|
||||
sMemcard1->Add(m_MemcardList[0], 1, wxEXPAND|wxALL, 5);
|
||||
sMemcard2->Add(m_Memcard2Path, 0, wxEXPAND|wxALL, 5);
|
||||
sMemcard2->Add(m_MemcardList[1], 1, wxEXPAND|wxALL, 5);
|
||||
|
||||
//wxBoxSizer* sMain;
|
||||
sMain = new wxBoxSizer(wxHORIZONTAL);
|
||||
sMain->Add(sMemcard1, 1, wxEXPAND|wxALL, 5);
|
||||
sMain->Add(sButtons, 0, wxEXPAND, 0);
|
||||
sMain->Add(sMemcard2, 1, wxEXPAND|wxALL, 5);
|
||||
|
||||
CenterOnParent();
|
||||
this->SetSizer(sMain);
|
||||
sMain->SetSizeHints(this);
|
||||
}
|
||||
|
||||
void CMemcardManager::OnClose(wxCloseEvent& WXUNUSED (event))
|
||||
{
|
||||
Destroy();
|
||||
}
|
||||
|
||||
void CMemcardManager::OnPathChange(wxFileDirPickerEvent& event)
|
||||
{
|
||||
switch(event.GetId())
|
||||
{
|
||||
case ID_MEMCARD1PATH:
|
||||
ReloadMemcard(event.GetPath().mb_str(), 0);
|
||||
break;
|
||||
case ID_MEMCARD2PATH:
|
||||
ReloadMemcard(event.GetPath().mb_str(), 1);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void CMemcardManager::CopyDeleteClick(wxCommandEvent& event)
|
||||
{
|
||||
int index0 = m_MemcardList[0]->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);;
|
||||
int index1 = m_MemcardList[1]->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);;
|
||||
|
||||
switch(event.GetId())
|
||||
{
|
||||
case ID_COPYRIGHT:
|
||||
if(index0 != -1 && m_MemcardList[1]->GetItemCount() > 0)
|
||||
{
|
||||
memoryCard[1]->CopyFrom(*memoryCard[0], index0);
|
||||
memoryCard[1]->Save();
|
||||
ReloadMemcard(m_Memcard2Path->GetPath().mb_str(), 1);
|
||||
}
|
||||
break;
|
||||
case ID_COPYLEFT:
|
||||
if(index1 != -1 && m_MemcardList[0]->GetItemCount() > 0)
|
||||
{
|
||||
memoryCard[0]->CopyFrom(*memoryCard[1], index1);
|
||||
memoryCard[0]->Save();
|
||||
ReloadMemcard(m_Memcard1Path->GetPath().mb_str(), 0);
|
||||
}
|
||||
break;
|
||||
case ID_DELETERIGHT:
|
||||
if(index1 != -1)
|
||||
{
|
||||
memoryCard[1]->RemoveFile(index1);
|
||||
memoryCard[1]->Save();
|
||||
ReloadMemcard(m_Memcard2Path->GetPath().mb_str(), 1);
|
||||
}
|
||||
break;
|
||||
case ID_DELETELEFT:
|
||||
if(index0 != -1)
|
||||
{
|
||||
memoryCard[0]->RemoveFile(index0);
|
||||
memoryCard[0]->Save();
|
||||
ReloadMemcard(m_Memcard1Path->GetPath().mb_str(), 0);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void CMemcardManager::ReloadMemcard(const char *fileName, int card)
|
||||
{
|
||||
if(memoryCard[card]) delete memoryCard[card];
|
||||
|
||||
// TODO: add error checking and banners/icons
|
||||
memoryCard[card] = new GCMemcard(fileName);
|
||||
|
||||
m_MemcardList[card]->Hide();
|
||||
m_MemcardList[card]->ClearAll();
|
||||
m_MemcardList[card]->InsertColumn(COLUMN_BANNER, _T("Banner"));
|
||||
m_MemcardList[card]->InsertColumn(COLUMN_TITLE, _T("Title"));
|
||||
m_MemcardList[card]->InsertColumn(COLUMN_COMMENT, _T("Comment"));
|
||||
m_MemcardList[card]->InsertColumn(COLUMN_ICON, _T("Icon"));
|
||||
|
||||
wxImageList *list=m_MemcardList[card]->GetImageList(wxIMAGE_LIST_SMALL);
|
||||
list->RemoveAll();
|
||||
|
||||
int nFiles = memoryCard[card]->GetNumFiles();
|
||||
|
||||
int *images = new int[nFiles*2];
|
||||
for(int i=0;i<nFiles;i++)
|
||||
{
|
||||
static u32 pxdata[96*32];
|
||||
static u8 animDelay[8];
|
||||
static u32 animData[32*32*8];
|
||||
|
||||
int numFrames = memoryCard[card]->ReadAnimRGBA8(i,animData,animDelay);
|
||||
|
||||
if(!memoryCard[card]->ReadBannerRGBA8(i,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);
|
||||
for(int y=0;y<32;y++)
|
||||
{
|
||||
for(int x=0;x<32;x++)
|
||||
{
|
||||
pxdata[y*96+x] = animData[y*32+x];
|
||||
}
|
||||
}
|
||||
|
||||
wxBitmap icon = wxBitmapFromMemoryRGBA((u8*)pxdata,96,32);
|
||||
images[i*2+1] = list->Add(icon);
|
||||
}
|
||||
}
|
||||
|
||||
for(int i=0;i<nFiles;i++)
|
||||
{
|
||||
char title[32];
|
||||
char comment[32];
|
||||
|
||||
if(!memoryCard[card]->GetComment1(i,title)) title[0]=0;
|
||||
if(!memoryCard[card]->GetComment2(i,comment)) comment[0]=0;
|
||||
|
||||
int index = m_MemcardList[card]->InsertItem(i, wxString::FromAscii("row"));
|
||||
m_MemcardList[card]->SetItem(index, COLUMN_BANNER, wxString::FromAscii(""));
|
||||
m_MemcardList[card]->SetItem(index, COLUMN_TITLE, wxString::FromAscii(title));
|
||||
m_MemcardList[card]->SetItem(index, COLUMN_COMMENT, wxString::FromAscii(comment));
|
||||
m_MemcardList[card]->SetItem(index, COLUMN_ICON, wxString::FromAscii(""));
|
||||
|
||||
if(images[i]>=0)
|
||||
{
|
||||
m_MemcardList[card]->SetItemImage(index, images[i*2]);
|
||||
m_MemcardList[card]->SetItemColumnImage(index, COLUMN_ICON, images[i*2+1]);
|
||||
}
|
||||
}
|
||||
m_MemcardList[card]->Show();
|
||||
|
||||
delete[] images;
|
||||
|
||||
// automatic column width
|
||||
for (int i = 0; i < m_MemcardList[card]->GetColumnCount(); i++)
|
||||
{
|
||||
m_MemcardList[card]->SetColumnWidth(i, wxLIST_AUTOSIZE);
|
||||
}
|
||||
}
|
||||
91
Source/Core/DolphinWX/Src/MemcardManager.h
Normal file
91
Source/Core/DolphinWX/Src/MemcardManager.h
Normal file
|
|
@ -0,0 +1,91 @@
|
|||
// Copyright (C) 2003-2008 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/
|
||||
|
||||
#ifndef __MEMCARD_MANAGER_h__
|
||||
#define __MEMCARD_MANAGER_h__
|
||||
|
||||
#include <wx/sizer.h>
|
||||
#include <wx/filepicker.h>
|
||||
#include <wx/statbmp.h>
|
||||
#include <wx/stattext.h>
|
||||
#include <wx/listctrl.h>
|
||||
#include <wx/imaglist.h>
|
||||
|
||||
#include "MemoryCards/GCMemcard.h"
|
||||
|
||||
#undef MEMCARD_MANAGER_STYLE
|
||||
#define MEMCARD_MANAGER_STYLE wxCAPTION | wxSYSTEM_MENU | wxDIALOG_NO_PARENT | wxCLOSE_BOX | wxRESIZE_BORDER | wxMAXIMIZE_BOX
|
||||
|
||||
class CMemcardManager
|
||||
: public wxDialog
|
||||
{
|
||||
public:
|
||||
|
||||
CMemcardManager(wxWindow* parent, wxWindowID id = 1, const wxString& title = wxT("Memory Card Manager WARNING-Make backups before using, will probably mangle stuff!"), const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = MEMCARD_MANAGER_STYLE);
|
||||
virtual ~CMemcardManager();
|
||||
|
||||
private:
|
||||
|
||||
DECLARE_EVENT_TABLE();
|
||||
|
||||
wxBoxSizer* sMain;
|
||||
wxButton* m_CopyRight;
|
||||
wxButton* m_CopyLeft;
|
||||
wxButton* m_DeleteRight;
|
||||
wxButton* m_DeleteLeft;
|
||||
wxStaticBoxSizer* sMemcard1;
|
||||
wxStaticBoxSizer* sMemcard2;
|
||||
wxFilePickerCtrl* m_Memcard1Path;
|
||||
wxFilePickerCtrl* m_Memcard2Path;
|
||||
wxListCtrl* m_MemcardList[2];
|
||||
wxTimer* m_Timer;
|
||||
|
||||
int nframe;
|
||||
|
||||
enum
|
||||
{
|
||||
ID_COPYRIGHT = 1000,
|
||||
ID_COPYLEFT,
|
||||
ID_DELETERIGHT,
|
||||
ID_DELETELEFT,
|
||||
ID_MEMCARD1PATH,
|
||||
ID_MEMCARD2PATH,
|
||||
ID_MEMCARD1LIST,
|
||||
ID_MEMCARD2LIST,
|
||||
ID_DUMMY_VALUE_ //don't remove this value unless you have other enum values
|
||||
};
|
||||
|
||||
enum
|
||||
{
|
||||
COLUMN_BANNER = 0,
|
||||
COLUMN_TITLE,
|
||||
COLUMN_COMMENT,
|
||||
COLUMN_ICON,
|
||||
NUMBER_OF_COLUMN
|
||||
};
|
||||
|
||||
GCMemcard *memoryCard[2];
|
||||
|
||||
void CreateGUIControls();
|
||||
void OnClose(wxCloseEvent& event);
|
||||
void CopyDeleteClick(wxCommandEvent& event);
|
||||
void ReloadMemcard(const char *fileName, int card);
|
||||
void OnPathChange(wxFileDirPickerEvent& event);
|
||||
void OnTimer(wxTimerEvent& event);
|
||||
};
|
||||
|
||||
#endif
|
||||
655
Source/Core/DolphinWX/Src/MemoryCards/GCMemcard.cpp
Normal file
655
Source/Core/DolphinWX/Src/MemoryCards/GCMemcard.cpp
Normal file
|
|
@ -0,0 +1,655 @@
|
|||
// gcmc.cpp: define el punto de entrada de la aplicación de consola.
|
||||
//
|
||||
#ifdef _WIN32
|
||||
#include "stdafx.h"
|
||||
#endif
|
||||
#include <assert.h>
|
||||
#include <memory.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include "GCMemcard.h"
|
||||
|
||||
void GCMemcard::calc_checksumsBE(u16 *buf, u32 num, u16 *c1, u16 *c2)
|
||||
{
|
||||
*c1 = 0;*c2 = 0;
|
||||
for (u32 i = 0; i < num; ++i)
|
||||
{
|
||||
//weird warnings here
|
||||
*c1 += bswap16(buf[i]);
|
||||
*c2 += bswap16((u16)(buf[i] ^ 0xffff));
|
||||
}
|
||||
if (*c1 == 0xffff)
|
||||
{
|
||||
*c1 = 0;
|
||||
}
|
||||
if (*c2 == 0xffff)
|
||||
{
|
||||
*c2 = 0;
|
||||
}
|
||||
}
|
||||
|
||||
u32 GCMemcard::GetNumFiles()
|
||||
{
|
||||
if(!mcdFile) return 0;
|
||||
|
||||
for(int i=0;i<126;i++)
|
||||
{
|
||||
if(BE32(dir.Dir[i].Gamecode)==0xFFFFFFFF)
|
||||
return i;
|
||||
}
|
||||
return 127;
|
||||
}
|
||||
|
||||
bool GCMemcard::RemoveFile(u32 index) //index in the directory array
|
||||
{
|
||||
if(!mcdFile) return false;
|
||||
|
||||
//backup the directory and bat (not really needed here but meh :P
|
||||
dir_backup=dir;
|
||||
bat_backup=bat;
|
||||
|
||||
int totalspace = (((u32)BE16(hdr.Size)*16)-5);
|
||||
|
||||
//free the blocks
|
||||
int blocks_left = BE16(dir.Dir[index].BlockCount);
|
||||
int block = BE16(dir.Dir[index].FirstBlock);
|
||||
do
|
||||
{
|
||||
int cbi = block-5;
|
||||
int nextblock=bswap16(bat.Map[cbi]);
|
||||
//assert(nextblock!=0);
|
||||
if(nextblock==0)
|
||||
{
|
||||
nextblock = block+1;
|
||||
}
|
||||
|
||||
bat.Map[cbi]=0;
|
||||
|
||||
block=nextblock;
|
||||
blocks_left--;
|
||||
}
|
||||
while((block!=0xffff)&&(blocks_left>0));
|
||||
|
||||
//delete directory entry
|
||||
for(int i=index;i<125;i++)
|
||||
{
|
||||
dir.Dir[i]=dir.Dir[i+1];
|
||||
}
|
||||
memset(&(dir.Dir[125]),0xFF,sizeof(DEntry));
|
||||
|
||||
//pack blocks to remove free space partitioning, assume no fragmentation.
|
||||
u8 *mc_data2 = new u8[mc_data_size];
|
||||
|
||||
int firstFree=0;
|
||||
for(int i=0;i<126;i++)
|
||||
{
|
||||
if(BE32(dir.Dir[i].Gamecode)==0xFFFFFFFF)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
int fb = BE16(dir.Dir[i].FirstBlock);
|
||||
int bc = BE16(dir.Dir[i].BlockCount);
|
||||
|
||||
u8* src = mc_data + (fb-5)*0x2000;
|
||||
u8* dst = mc_data2 + firstFree*0x2000;
|
||||
|
||||
memcpy(dst,src,bc*0x2000);
|
||||
|
||||
for(int j=0;j<bc;j++)
|
||||
{
|
||||
bat.Map[firstFree+j] = bswap16(u16(firstFree+j+6));
|
||||
}
|
||||
bat.Map[firstFree+bc-1] = 0xFFFF;
|
||||
|
||||
dir.Dir[i].FirstBlock[0] = u8((firstFree+5)>>8);
|
||||
dir.Dir[i].FirstBlock[1] = u8((firstFree+5));
|
||||
|
||||
firstFree += bc;
|
||||
}
|
||||
|
||||
for(int j=firstFree;j<totalspace;j++)
|
||||
{
|
||||
bat.Map[j] = 0;
|
||||
}
|
||||
|
||||
firstFree+=4;
|
||||
bat.LastAllocated[0] = u8(firstFree>>8);
|
||||
bat.LastAllocated[1] = u8(firstFree);
|
||||
|
||||
delete [] mc_data;
|
||||
mc_data = mc_data2;
|
||||
//--
|
||||
|
||||
//update freespace counter
|
||||
int freespace1 = totalspace - firstFree;
|
||||
bat.FreeBlocks[0] = u8(freespace1>>8);
|
||||
bat.FreeBlocks[1] = u8(freespace1);
|
||||
|
||||
// ... and update counter
|
||||
int updateCtr = BE16(dir.UpdateCounter)+1;
|
||||
dir.UpdateCounter[0] = u8(updateCtr>>8);
|
||||
dir.UpdateCounter[1] = u8(updateCtr);
|
||||
|
||||
//fix checksums
|
||||
u16 csum1=0,csum2=0;
|
||||
calc_checksumsBE((u16*)&dir,0xFFE,&csum1,&csum2);
|
||||
dir.CheckSum1[0]=u8(csum1>>8);
|
||||
dir.CheckSum1[1]=u8(csum1);
|
||||
dir.CheckSum2[0]=u8(csum2>>8);
|
||||
dir.CheckSum2[1]=u8(csum2);
|
||||
calc_checksumsBE((u16*)(((u8*)&bat)+4),0xFFE,&csum1,&csum2);
|
||||
bat.CheckSum1[0]=u8(csum1>>8);
|
||||
bat.CheckSum1[1]=u8(csum1);
|
||||
bat.CheckSum2[0]=u8(csum2>>8);
|
||||
bat.CheckSum2[1]=u8(csum2);
|
||||
|
||||
dir_backup=dir;
|
||||
bat_backup=bat;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
u32 GCMemcard::ImportFile(DEntry& direntry, u8* contents)
|
||||
{
|
||||
if(!mcdFile) return 0;
|
||||
|
||||
if(BE16(bat.FreeBlocks)<BE16(direntry.BlockCount))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// find first free data block -- assume no freespace fragmentation
|
||||
int totalspace = (((u32)BE16(hdr.Size)*16)-5);
|
||||
|
||||
int firstFree1 = BE16(bat.LastAllocated)+1;
|
||||
|
||||
int firstFree2 = 0;
|
||||
for(int i=0;i<totalspace;i++)
|
||||
{
|
||||
if(bat.Map[i]==0)
|
||||
{
|
||||
firstFree2=i+5;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
int firstFree3 = 0;
|
||||
for(int i=0;i<126;i++)
|
||||
{
|
||||
if(BE32(dir.Dir[i].Gamecode)==0xFFFFFFFF)
|
||||
{
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
firstFree3 = max(firstFree3,BE16(dir.Dir[i].FirstBlock) + BE16(dir.Dir[i].BlockCount));
|
||||
}
|
||||
}
|
||||
|
||||
if(firstFree2 > firstFree1) firstFree1 = firstFree2;
|
||||
if(firstFree3 > firstFree1) firstFree1 = firstFree3;
|
||||
|
||||
if(firstFree1>=126)
|
||||
{
|
||||
// TODO: show messagebox about the error
|
||||
return 0;
|
||||
}
|
||||
|
||||
// find first free dir entry
|
||||
int index=-1;
|
||||
for(int i=0;i<127;i++)
|
||||
{
|
||||
if(BE32(dir.Dir[i].Gamecode)==0xFFFFFFFF)
|
||||
{
|
||||
index=i;
|
||||
dir.Dir[i] = direntry;
|
||||
dir.Dir[i].FirstBlock[0] = u8(firstFree1>>8);
|
||||
dir.Dir[i].FirstBlock[1] = u8(firstFree1);
|
||||
dir.Dir[i].CopyCounter = dir.Dir[i].CopyCounter+1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// keep assuming no freespace fragmentation, and copy over all the data
|
||||
u8*destination = mc_data + (firstFree1-5)*0x2000;
|
||||
|
||||
int fileBlocks=BE16(direntry.BlockCount);
|
||||
memcpy(destination,contents,0x2000*fileBlocks);
|
||||
|
||||
|
||||
//update freespace counter
|
||||
int freespace1 = totalspace - firstFree1;
|
||||
bat.FreeBlocks[0] = u8(freespace1>>8);
|
||||
bat.FreeBlocks[1] = u8(freespace1);
|
||||
|
||||
// ... and update counter
|
||||
int updateCtr = BE16(dir.UpdateCounter)+1;
|
||||
dir.UpdateCounter[0] = u8(updateCtr>>8);
|
||||
dir.UpdateCounter[1] = u8(updateCtr);
|
||||
|
||||
//fix checksums
|
||||
u16 csum1=0,csum2=0;
|
||||
calc_checksumsBE((u16*)&dir,0xFFE,&csum1,&csum2);
|
||||
dir.CheckSum1[0]=u8(csum1>>8);
|
||||
dir.CheckSum1[1]=u8(csum1);
|
||||
dir.CheckSum2[0]=u8(csum2>>8);
|
||||
dir.CheckSum2[1]=u8(csum2);
|
||||
calc_checksumsBE((u16*)(((u8*)&bat)+4),0xFFE,&csum1,&csum2);
|
||||
bat.CheckSum1[0]=u8(csum1>>8);
|
||||
bat.CheckSum1[1]=u8(csum1);
|
||||
bat.CheckSum2[0]=u8(csum2>>8);
|
||||
bat.CheckSum2[1]=u8(csum2);
|
||||
|
||||
return fileBlocks;
|
||||
}
|
||||
|
||||
bool GCMemcard::GetFileData(u32 index, u8*dest) //index in the directory array
|
||||
{
|
||||
if(!mcdFile) return false;
|
||||
|
||||
int block = BE16(dir.Dir[index].FirstBlock);
|
||||
assert((block!=0xFFFF)&&(block>0));
|
||||
do
|
||||
{
|
||||
int nextblock=bswap16(bat.Map[block-5]);
|
||||
assert(nextblock>0);
|
||||
|
||||
memcpy(dest,mc_data + 0x2000*(block-5),0x2000);
|
||||
dest+=0x2000;
|
||||
|
||||
block=nextblock;
|
||||
}
|
||||
while(block!=0xffff);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
u32 GCMemcard::GetFileSize(u32 index) //index in the directory array
|
||||
{
|
||||
if(!mcdFile) return 0;
|
||||
|
||||
return BE16(dir.Dir[index].BlockCount);
|
||||
}
|
||||
|
||||
bool GCMemcard::GetFileInfo(u32 index, GCMemcard::DEntry& info) //index in the directory array
|
||||
{
|
||||
if(!mcdFile) return false;
|
||||
|
||||
info = dir.Dir[index];
|
||||
return true;
|
||||
}
|
||||
bool GCMemcard::GetFileName(u32 index, char *fn) //index in the directory array
|
||||
{
|
||||
if(!mcdFile) return false;
|
||||
|
||||
memcpy(fn,(const char*)dir.Dir[index].Filename,32);
|
||||
fn[31]=0;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool GCMemcard::GetComment1(u32 index, char *fn) //index in the directory array
|
||||
{
|
||||
if(!mcdFile) return false;
|
||||
|
||||
u32 Comment1 =BE32(dir.Dir[index].CommentsAddr);
|
||||
u32 DataBlock =BE16(dir.Dir[index].FirstBlock)-5;
|
||||
if(Comment1==0xFFFFFFFF)
|
||||
{
|
||||
fn[0]=0;
|
||||
return false;
|
||||
}
|
||||
|
||||
memcpy(fn,mc_data +(DataBlock*0x2000) + Comment1,32);
|
||||
fn[31]=0;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool GCMemcard::GetComment2(u32 index, char *fn) //index in the directory array
|
||||
{
|
||||
if(!mcdFile) return false;
|
||||
|
||||
u32 Comment1 =BE32(dir.Dir[index].CommentsAddr);
|
||||
u32 Comment2 =Comment1+32;
|
||||
u32 DataBlock =BE16(dir.Dir[index].FirstBlock)-5;
|
||||
if(Comment1==0xFFFFFFFF)
|
||||
{
|
||||
fn[0]=0;
|
||||
return false;
|
||||
}
|
||||
|
||||
memcpy(fn,mc_data +(DataBlock*0x2000) + Comment2,32);
|
||||
fn[31]=0;
|
||||
return true;
|
||||
}
|
||||
|
||||
u32 decode5A3(u16 val)
|
||||
{
|
||||
const int lut5to8[] = { 0x00,0x08,0x10,0x18,0x20,0x29,0x31,0x39,
|
||||
0x41,0x4A,0x52,0x5A,0x62,0x6A,0x73,0x7B,
|
||||
0x83,0x8B,0x94,0x9C,0xA4,0xAC,0xB4,0xBD,
|
||||
0xC5,0xCD,0xD5,0xDE,0xE6,0xEE,0xF6,0xFF};
|
||||
const int lut4to8[] = { 0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,
|
||||
0x88,0x99,0xAA,0xBB,0xCC,0xDD,0xEE,0xFF};
|
||||
const int lut3to8[] = { 0x00,0x24,0x48,0x6D,0x91,0xB6,0xDA,0xFF};
|
||||
|
||||
|
||||
int r,g,b,a;
|
||||
if ((val&0x8000))
|
||||
{
|
||||
r=lut5to8[(val>>10) & 0x1f];
|
||||
g=lut5to8[(val>>5 ) & 0x1f];
|
||||
b=lut5to8[(val ) & 0x1f];
|
||||
a=0xFF;
|
||||
}
|
||||
else
|
||||
{
|
||||
a=lut3to8[(val>>12) & 0x7];
|
||||
r=lut4to8[(val>>8 ) & 0xf];
|
||||
g=lut4to8[(val>>4 ) & 0xf];
|
||||
b=lut4to8[(val ) & 0xf];
|
||||
}
|
||||
return (a<<24) | (r<<16) | (g<<8) | b;
|
||||
}
|
||||
|
||||
void decode5A3image(u32* dst, u16* src, int width, int height)
|
||||
{
|
||||
for (int y = 0; y < height; y += 4)
|
||||
{
|
||||
for (int x = 0; x < width; x += 4)
|
||||
{
|
||||
for (int iy = 0; iy < 4; iy++, src += 4)
|
||||
{
|
||||
for (int ix = 0; ix < 4; ix++)
|
||||
{
|
||||
u32 RGBA = decode5A3(bswap16(src[ix]));
|
||||
dst[(y + iy) * width + (x + ix)] = RGBA;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void decodeCI8image(u32* dst, u8* src, u16* pal, int width, int height)
|
||||
{
|
||||
for (int y = 0; y < height; y += 4)
|
||||
{
|
||||
for (int x = 0; x < width; x += 8)
|
||||
{
|
||||
for (int iy = 0; iy < 4; iy++, src += 8)
|
||||
{
|
||||
u32 *tdst = dst+(y+iy)*width+x;
|
||||
for (int ix = 0; ix < 8; ix++)
|
||||
{
|
||||
tdst[ix] = decode5A3(bswap16(pal[src[ix]]));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool GCMemcard::ReadBannerRGBA8(u32 index, u32* buffer)
|
||||
{
|
||||
if(!mcdFile) return false;
|
||||
|
||||
int flags = dir.Dir[index].BIFlags;
|
||||
|
||||
int bnrFormat = (flags&3);
|
||||
|
||||
if(bnrFormat==0)
|
||||
return false;
|
||||
|
||||
u32 DataOffset=BE32(dir.Dir[index].ImageOffset);
|
||||
u32 DataBlock =BE16(dir.Dir[index].FirstBlock)-5;
|
||||
|
||||
if(DataOffset==0xFFFFFFFF)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
const int pixels = 96*32;
|
||||
|
||||
if(bnrFormat&1)
|
||||
{
|
||||
u8 *pxdata = (u8* )(mc_data +(DataBlock*0x2000) + DataOffset);
|
||||
u16 *paldata = (u16*)(mc_data +(DataBlock*0x2000) + DataOffset + pixels);
|
||||
|
||||
decodeCI8image(buffer,pxdata,paldata,96,32);
|
||||
}
|
||||
else
|
||||
{
|
||||
u16 *pxdata = (u16*)(mc_data +(DataBlock*0x2000) + DataOffset);
|
||||
|
||||
decode5A3image(buffer,pxdata,96,32);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
u32 GCMemcard::ReadAnimRGBA8(u32 index, u32* buffer, u8 *delays)
|
||||
{
|
||||
if(!mcdFile) return 0;
|
||||
|
||||
int formats = BE16(dir.Dir[index].IconFmt);
|
||||
int fdelays = BE16(dir.Dir[index].AnimSpeed);
|
||||
|
||||
int flags = dir.Dir[index].BIFlags;
|
||||
|
||||
int bnrFormat = (flags&3);
|
||||
|
||||
u32 DataOffset=BE32(dir.Dir[index].ImageOffset);
|
||||
u32 DataBlock =BE16(dir.Dir[index].FirstBlock)-5;
|
||||
|
||||
if(DataOffset==0xFFFFFFFF)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
u8* animData=(u8*)(mc_data +(DataBlock*0x2000) + DataOffset);
|
||||
|
||||
switch(bnrFormat)
|
||||
{
|
||||
case 1:
|
||||
case 3:
|
||||
animData+=96*32 + 2*256; // image+palette
|
||||
break;
|
||||
case 2:
|
||||
animData+=96*32*2;
|
||||
break;
|
||||
}
|
||||
|
||||
int fmts[8];
|
||||
u8* data[8];
|
||||
int frames = 0;
|
||||
|
||||
|
||||
for(int i=0;i<8;i++)
|
||||
{
|
||||
fmts[i] = (formats>>(2*i))&3;
|
||||
delays[i] = ((fdelays>>(2*i))&3)<<2;
|
||||
data[i] = animData;
|
||||
|
||||
switch(fmts[i])
|
||||
{
|
||||
case 1: // CI8 with shared palette
|
||||
animData+=32*32;
|
||||
frames++;
|
||||
break;
|
||||
case 2: // RGB5A3
|
||||
animData+=32*32*2;
|
||||
frames++;
|
||||
break;
|
||||
case 3: // CI8 with own palette
|
||||
animData+=32*32 + 2*256;
|
||||
frames++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
u16* sharedPal = (u16*)(animData);
|
||||
|
||||
for(int i=0;i<8;i++)
|
||||
{
|
||||
switch(fmts[i])
|
||||
{
|
||||
case 1: // CI8 with shared palette
|
||||
decodeCI8image(buffer,data[i],sharedPal,32,32);
|
||||
buffer+=32*32;
|
||||
break;
|
||||
case 2: // RGB5A3
|
||||
decode5A3image(buffer,(u16*)(data[i]),32,32);
|
||||
break;
|
||||
case 3: // CI8 with own palette
|
||||
u16 *paldata = (u16*)(data[i]+32*32);
|
||||
decodeCI8image(buffer,data[i],paldata,32,32);
|
||||
buffer+=32*32;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return frames;
|
||||
}
|
||||
|
||||
u32 GCMemcard::TestChecksums()
|
||||
{
|
||||
if(!mcdFile) return 0xFFFFFFFF;
|
||||
|
||||
u16 csum1=0,csum2=0;
|
||||
|
||||
u32 results = 0;
|
||||
|
||||
calc_checksumsBE((u16*)&hdr, 0xFE ,&csum1,&csum2);
|
||||
if(BE16(hdr.CheckSum1)!=csum1) results |= 1;
|
||||
if(BE16(hdr.CheckSum2)!=csum2) results |= 1;
|
||||
|
||||
calc_checksumsBE((u16*)&dir,0xFFE,&csum1,&csum2);
|
||||
if(BE16(dir.CheckSum1)!=csum1) results |= 2;
|
||||
if(BE16(dir.CheckSum2)!=csum2) results |= 2;
|
||||
|
||||
calc_checksumsBE((u16*)&dir_backup,0xFFE,&csum1,&csum2);
|
||||
if(BE16(dir_backup.CheckSum1)!=csum1) results |= 4;
|
||||
if(BE16(dir_backup.CheckSum2)!=csum2) results |= 4;
|
||||
|
||||
calc_checksumsBE((u16*)(((u8*)&bat)+4),0xFFE,&csum1,&csum2);
|
||||
if(BE16(bat.CheckSum1)!=csum1) results |= 8;
|
||||
if(BE16(bat.CheckSum2)!=csum2) results |= 8;
|
||||
|
||||
calc_checksumsBE((u16*)(((u8*)&bat_backup)+4),0xFFE,&csum1,&csum2);
|
||||
if(BE16(bat_backup.CheckSum1)!=csum1) results |= 16;
|
||||
if(BE16(bat_backup.CheckSum2)!=csum2) results |= 16;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
u32 GCMemcard::CopyFrom(GCMemcard& source, u32 index)
|
||||
{
|
||||
if(!mcdFile) return 0;
|
||||
|
||||
DEntry d;
|
||||
if(!source.GetFileInfo(index,d)) return 0;
|
||||
|
||||
u8 *t = new u8[source.GetFileSize(index)*0x2000];
|
||||
|
||||
if(!source.GetFileData(index,t)) return 0;
|
||||
u32 ret = ImportFile(d,t);
|
||||
|
||||
delete[] t;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool GCMemcard::Save()
|
||||
{
|
||||
if(!mcdFile) return false;
|
||||
|
||||
FILE *mcd=(FILE*)mcdFile;
|
||||
fseek(mcd,0,SEEK_SET);
|
||||
fwrite(&hdr,1,0x2000,mcd);
|
||||
fwrite(&dir,1,0x2000,mcd);
|
||||
fwrite(&dir_backup,1,0x2000,mcd);
|
||||
fwrite(&bat,1,0x2000,mcd);
|
||||
fwrite(&bat_backup,1,0x2000,mcd);
|
||||
fwrite(mc_data,1,mc_data_size,mcd);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool GCMemcard::IsOpen()
|
||||
{
|
||||
return (mcdFile!=NULL);
|
||||
}
|
||||
|
||||
GCMemcard::GCMemcard(const char *filename)
|
||||
{
|
||||
FILE *mcd=fopen(filename,"r+b");
|
||||
mcdFile=mcd;
|
||||
if(!mcd) return;
|
||||
|
||||
fseek(mcd,0x0000,SEEK_SET);
|
||||
assert(fread(&hdr, 1,0x2000,mcd)==0x2000);
|
||||
assert(fread(&dir, 1,0x2000,mcd)==0x2000);
|
||||
assert(fread(&dir_backup,1,0x2000,mcd)==0x2000);
|
||||
assert(fread(&bat, 1,0x2000,mcd)==0x2000);
|
||||
assert(fread(&bat_backup,1,0x2000,mcd)==0x2000);
|
||||
|
||||
u32 csums = TestChecksums();
|
||||
|
||||
if(csums&1)
|
||||
{
|
||||
// header checksum error!
|
||||
// TODO: fail to load
|
||||
}
|
||||
|
||||
if(csums&2) // directory checksum error!
|
||||
{
|
||||
if(csums&4)
|
||||
{
|
||||
// backup is also wrong!
|
||||
// TODO: fail to load
|
||||
}
|
||||
else
|
||||
{
|
||||
// backup is correct, restore
|
||||
dir = dir_backup;
|
||||
bat = bat_backup;
|
||||
|
||||
// update checksums
|
||||
csums = TestChecksums();
|
||||
}
|
||||
}
|
||||
|
||||
if(csums&8) // BAT checksum error!
|
||||
{
|
||||
if(csums&16)
|
||||
{
|
||||
// backup is also wrong!
|
||||
// TODO: fail to load
|
||||
}
|
||||
else
|
||||
{
|
||||
// backup is correct, restore
|
||||
dir = dir_backup;
|
||||
bat = bat_backup;
|
||||
|
||||
// update checksums
|
||||
csums = TestChecksums();
|
||||
}
|
||||
}
|
||||
|
||||
if(BE16(dir_backup.UpdateCounter) > BE16(dir.UpdateCounter)) //check if the backup is newer
|
||||
{
|
||||
dir = dir_backup;
|
||||
bat = bat_backup; // needed?
|
||||
}
|
||||
|
||||
fseek(mcd,0xa000,SEEK_SET);
|
||||
|
||||
mc_data_size=(((u32)BE16(hdr.Size)*16)-5)*0x2000;
|
||||
mc_data = new u8[mc_data_size];
|
||||
|
||||
u32 read = fread(mc_data,1,mc_data_size,mcd);
|
||||
assert(mc_data_size==read);
|
||||
}
|
||||
|
||||
GCMemcard::~GCMemcard()
|
||||
{
|
||||
fclose((FILE*)mcdFile);
|
||||
}
|
||||
170
Source/Core/DolphinWX/Src/MemoryCards/GCMemcard.h
Normal file
170
Source/Core/DolphinWX/Src/MemoryCards/GCMemcard.h
Normal file
|
|
@ -0,0 +1,170 @@
|
|||
#pragma once
|
||||
|
||||
typedef unsigned char u8;
|
||||
typedef unsigned short u16;
|
||||
typedef unsigned int u32;
|
||||
|
||||
u16 __inline bswap16(u16 s)
|
||||
{
|
||||
return (s>>8) | (s<<8);
|
||||
}
|
||||
|
||||
u32 __inline bswap32(u32 s)
|
||||
{
|
||||
return (u32)bswap16((u16)(s>>16)) | ((u32)bswap16((u16)s)<<16);
|
||||
}
|
||||
|
||||
#ifndef max
|
||||
template<class T>
|
||||
T __inline max(T a, T b)
|
||||
{
|
||||
return (b>a)?b:a;
|
||||
}
|
||||
#endif
|
||||
|
||||
#define BE16(x) ((u16((x)[0])<<8) | u16((x)[1]))
|
||||
#define BE32(x) ((u32((x)[0])<<24) | (u32((x)[1])<<16) | (u32((x)[2])<<8) | u32((x)[3]))
|
||||
|
||||
class GCMemcard
|
||||
{
|
||||
void* mcdFile;
|
||||
|
||||
u32 mc_data_size;
|
||||
u8* mc_data;
|
||||
|
||||
void calc_checksumsBE(u16 *buf, u32 num, u16 *c1, u16 *c2);
|
||||
|
||||
public:
|
||||
|
||||
#pragma pack(push,1)
|
||||
struct OSTime {
|
||||
u32 low;
|
||||
u32 high;
|
||||
};
|
||||
|
||||
struct Header { //Offset Size Description
|
||||
u8 Unk[12]; //0x0000 12 ?
|
||||
OSTime fmtTime; //0x000c 8 time of format (OSTime value)
|
||||
u8 UID[12]; //0x0014 12 unique card id (?)
|
||||
u8 Pad1[2]; //0x0020 2 padding zeroes
|
||||
u8 Size[2]; //0x0022 2 size of memcard in Mbits
|
||||
u8 Encoding[2]; //0x0024 2 encoding (ASCII or japanese)
|
||||
u8 Unused1[468]; //0x0026 468 unused (0xff)
|
||||
u8 UpdateCounter[2];//0x01fa 2 update Counter (?, probably unused)
|
||||
u8 CheckSum1[2]; //0x01fc 2 Checksum 1 (?)
|
||||
u8 CheckSum2[2]; //0x01fe 2 Checksum 2 (?)
|
||||
u8 Unused2[7680]; //0x0200 0x1e00 unused (0xff)
|
||||
} hdr;
|
||||
|
||||
struct DEntry {
|
||||
u8 Gamecode[4]; //0x00 0x04 Gamecode
|
||||
u8 Markercode[2]; //0x04 0x02 Makercode
|
||||
u8 Unused1; //0x06 0x01 reserved/unused (always 0xff, has no effect)
|
||||
u8 BIFlags; //0x07 0x01 banner gfx format and icon animation (Image Key)
|
||||
// bit(s) description
|
||||
// 2 Icon Animation 0: forward 1: ping-pong
|
||||
// 1 [--0: No Banner 1: Banner present--] WRONG! YAGCD LIES!
|
||||
// 0 [--Banner Color 0: RGB5A3 1: CI8--] WRONG! YAGCD LIES!
|
||||
// bits 0 and 1: image format
|
||||
// 00 no banner
|
||||
// 01 CI8 banner
|
||||
// 01 RGB5A3 banner
|
||||
// 11 ? maybe ==01? haven't seen it
|
||||
//
|
||||
u8 Filename[32]; //0x08 0x20 filename
|
||||
u8 ModTime[4]; //0x28 0x04 Time of file's last modification in seconds since 12am, January 1st, 2000
|
||||
u8 ImageOffset[4]; //0x2c 0x04 image data offset
|
||||
u8 IconFmt[2]; //0x30 0x02 icon gfx format (2bits per icon)
|
||||
// bits Description
|
||||
// 00 no icon
|
||||
// 01 CI8 with a shared color palette after the last frame
|
||||
// 10 RGB5A3
|
||||
// 11 CI8 with a unique color palette after itself
|
||||
//
|
||||
u8 AnimSpeed[2]; //0x32 0x02 animation speed (2bits per icon) (*1)
|
||||
// bits Description
|
||||
// 00 no icon
|
||||
// 01 Icon lasts for 4 frames
|
||||
// 10 Icon lasts for 8 frames
|
||||
// 11 Icon lasts for 12 frames
|
||||
//
|
||||
u8 Permissions; //0x34 0x01 file-permissions
|
||||
// bit permission Description
|
||||
// 4 no move File cannot be moved by the IPL
|
||||
// 3 no copy File cannot be copied by the IPL
|
||||
// 2 public Can be read by any game
|
||||
//
|
||||
u8 CopyCounter; //0x35 0x01 copy counter (*2)
|
||||
u8 FirstBlock[2]; //0x36 0x02 block no of first block of file (0 == offset 0)
|
||||
u8 BlockCount[2]; //0x38 0x02 file-length (number of blocks in file)
|
||||
u8 Unused2[2]; //0x3a 0x02 reserved/unused (always 0xffff, has no effect)
|
||||
u8 CommentsAddr[4]; //0x3c 0x04 Address of the two comments within the file data (*3)
|
||||
};
|
||||
|
||||
struct Directory {
|
||||
DEntry Dir[127]; //0x0000 Directory Entries (max 127)
|
||||
u8 Padding[0x3a];
|
||||
u8 UpdateCounter[2];//0x1ffa 2 update Counter
|
||||
u8 CheckSum1[2]; //0x1ffc 2 Checksum 1
|
||||
u8 CheckSum2[2]; //0x1ffe 2 Checksum 2
|
||||
} dir, dir_backup;
|
||||
|
||||
struct BlockAlloc {
|
||||
u8 CheckSum1[2]; //0x0000 2 Checksum 1
|
||||
u8 CheckSum2[2]; //0x0002 2 Checksum 2
|
||||
u8 UpdateCounter[2];//0x0004 2 update Counter
|
||||
u8 FreeBlocks[2]; //0x0006 2 free Blocks
|
||||
u8 LastAllocated[2];//0x0008 2 last allocated Block
|
||||
u16 Map[0xFFB]; //0x000a 0x1ff8 Map of allocated Blocks
|
||||
} bat,bat_backup;
|
||||
#pragma pack(pop)
|
||||
|
||||
// constructor
|
||||
GCMemcard(const char* fileName);
|
||||
|
||||
// destructor
|
||||
~GCMemcard();
|
||||
|
||||
bool IsOpen();
|
||||
|
||||
u32 TestChecksums();
|
||||
|
||||
// get number of file entries in the directory
|
||||
u32 GetNumFiles();
|
||||
|
||||
// read directory entry
|
||||
bool GetFileInfo(u32 index, DEntry& data);
|
||||
|
||||
// buffer needs to be a char[32] or bigger
|
||||
bool GetFileName(u32 index, char* buffer);
|
||||
|
||||
// buffer needs to be a char[32] or bigger
|
||||
bool GetComment1(u32 index, char* buffer);
|
||||
|
||||
// buffer needs to be a char[32] or bigger
|
||||
bool GetComment2(u32 index, char* buffer);
|
||||
|
||||
// get file length un bytes
|
||||
u32 GetFileSize(u32 index);
|
||||
|
||||
// assumes there's enough space in buffer
|
||||
bool GetFileData(u32 index, u8* buffer);
|
||||
|
||||
// delete a file from the directory
|
||||
bool RemoveFile(u32 index);
|
||||
|
||||
// adds the file to the directory and copies its contents
|
||||
u32 ImportFile(DEntry& direntry, u8* contents);
|
||||
|
||||
// reads a save from another memcard, and imports the data into this memcard
|
||||
u32 CopyFrom(GCMemcard& source, u32 index);
|
||||
|
||||
// reads the banner image
|
||||
bool ReadBannerRGBA8(u32 index, u32* buffer);
|
||||
|
||||
// reads the animation frames
|
||||
u32 ReadAnimRGBA8(u32 index, u32* buffer, u8 *delays);
|
||||
|
||||
bool Save();
|
||||
|
||||
};
|
||||
6
Source/Core/DolphinWX/Src/Params.ggo
Normal file
6
Source/Core/DolphinWX/Src/Params.ggo
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
package "Dolphin"
|
||||
version "SVN"
|
||||
purpose "A multi platform gamecube/wii emulator"
|
||||
|
||||
option "debug" d "enable debug" flag off
|
||||
|
||||
153
Source/Core/DolphinWX/Src/PluginManager.cpp
Normal file
153
Source/Core/DolphinWX/Src/PluginManager.cpp
Normal file
|
|
@ -0,0 +1,153 @@
|
|||
// Copyright (C) 2003-2008 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 <string>
|
||||
#include <vector>
|
||||
|
||||
#include "Globals.h"
|
||||
#include "FileSearch.h"
|
||||
#include "FileUtil.h"
|
||||
#include "PluginManager.h"
|
||||
#include "StringUtil.h"
|
||||
|
||||
CPluginManager CPluginManager::m_Instance;
|
||||
|
||||
|
||||
CPluginManager::CPluginManager()
|
||||
{}
|
||||
|
||||
|
||||
CPluginManager::~CPluginManager()
|
||||
{}
|
||||
|
||||
|
||||
void
|
||||
CPluginManager::ScanForPlugins(wxWindow* _wxWindow)
|
||||
{
|
||||
m_PluginInfos.clear();
|
||||
|
||||
CFileSearch::XStringVector Directories;
|
||||
Directories.push_back(std::string("Plugins"));
|
||||
|
||||
CFileSearch::XStringVector Extensions;
|
||||
#ifdef _WIN32
|
||||
Extensions.push_back("*.dll");
|
||||
#else
|
||||
Extensions.push_back("*.so");
|
||||
#endif
|
||||
|
||||
CFileSearch FileSearch(Extensions, Directories);
|
||||
const CFileSearch::XStringVector& rFilenames = FileSearch.GetFileNames();
|
||||
|
||||
if (rFilenames.size() > 0)
|
||||
{
|
||||
wxProgressDialog dialog(_T("Scanning for Plugins"),
|
||||
_T("Scanning..."),
|
||||
(int)rFilenames.size(), // range
|
||||
_wxWindow, // parent
|
||||
wxPD_CAN_ABORT |
|
||||
wxPD_APP_MODAL |
|
||||
// wxPD_AUTO_HIDE | -- try this as well
|
||||
wxPD_ELAPSED_TIME |
|
||||
wxPD_ESTIMATED_TIME |
|
||||
wxPD_REMAINING_TIME |
|
||||
wxPD_SMOOTH // - makes indeterminate mode bar on WinXP very small
|
||||
);
|
||||
dialog.CenterOnParent();
|
||||
|
||||
for (size_t i = 0; i < rFilenames.size(); i++)
|
||||
{
|
||||
std::string orig_name = rFilenames[i];
|
||||
std::string FileName;
|
||||
|
||||
if (!SplitPath(rFilenames[i], NULL, &FileName, NULL))
|
||||
{
|
||||
printf("Bad Path %s\n", rFilenames[i].c_str());
|
||||
return;
|
||||
}
|
||||
|
||||
wxString msg;
|
||||
char temp[128];
|
||||
sprintf(temp,"Scanning %s", FileName.c_str());
|
||||
msg = wxString::FromAscii(temp);
|
||||
bool Cont = dialog.Update((int)i, msg);
|
||||
|
||||
if (!Cont)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
CPluginInfo PluginInfo(orig_name);
|
||||
if (PluginInfo.IsValid())
|
||||
{
|
||||
m_PluginInfos.push_back(PluginInfo);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
CPluginManager::OpenAbout(void* _Parent, const std::string& _rFilename)
|
||||
{
|
||||
if (Common::CPlugin::Load(_rFilename.c_str()))
|
||||
{
|
||||
Common::CPlugin::About((HWND)_Parent);
|
||||
Common::CPlugin::Release();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
CPluginManager::OpenConfig(void* _Parent, const std::string& _rFilename)
|
||||
{
|
||||
if (Common::CPlugin::Load(_rFilename.c_str()))
|
||||
{
|
||||
Common::CPlugin::Config((HWND)_Parent);
|
||||
Common::CPlugin::Release();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
CPluginInfo::CPluginInfo(const std::string& _rFileName)
|
||||
: m_FileName(_rFileName)
|
||||
, m_Valid(false)
|
||||
{
|
||||
if (Common::CPlugin::Load(_rFileName.c_str()))
|
||||
{
|
||||
if (Common::CPlugin::GetInfo(m_PluginInfo))
|
||||
{
|
||||
m_Valid = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
PanicAlert("Could not get info about plugin %s", _rFileName.c_str());
|
||||
}
|
||||
|
||||
Common::CPlugin::Release();
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!File::Exists(_rFileName)) {
|
||||
PanicAlert("Could not load plugin %s - file does not exist", _rFileName.c_str());
|
||||
} else {
|
||||
PanicAlert("Failed to load plugin %s - unknown error.\n", _rFileName.c_str());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
80
Source/Core/DolphinWX/Src/PluginManager.h
Normal file
80
Source/Core/DolphinWX/Src/PluginManager.h
Normal file
|
|
@ -0,0 +1,80 @@
|
|||
// Copyright (C) 2003-2008 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/
|
||||
|
||||
#ifndef __PLUGIN_MANAGER_H_
|
||||
#define __PLUGIN_MANAGER_H_
|
||||
|
||||
#include "Plugin.h"
|
||||
|
||||
class CPluginInfo
|
||||
{
|
||||
public:
|
||||
|
||||
CPluginInfo(const std::string& _rFileName);
|
||||
|
||||
bool IsValid() const {return(m_Valid);}
|
||||
|
||||
|
||||
const PLUGIN_INFO& GetPluginInfo() const {return(m_PluginInfo);}
|
||||
|
||||
|
||||
const std::string& GetFileName() const {return(m_FileName);}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
PLUGIN_INFO m_PluginInfo;
|
||||
|
||||
std::string m_FileName;
|
||||
|
||||
bool m_Valid;
|
||||
};
|
||||
|
||||
typedef std::vector<CPluginInfo>CPluginInfos;
|
||||
|
||||
class CPluginManager
|
||||
{
|
||||
public:
|
||||
|
||||
static CPluginManager& GetInstance() {return(m_Instance);}
|
||||
|
||||
|
||||
void ScanForPlugins(wxWindow* _wxWindow);
|
||||
|
||||
void OpenAbout(void* _Parent, const std::string& _rFilename);
|
||||
|
||||
void OpenConfig(void* _Parent, const std::string& _rFilename);
|
||||
|
||||
|
||||
const CPluginInfos& GetPluginInfos() {return(m_PluginInfos);}
|
||||
|
||||
|
||||
private:
|
||||
|
||||
static CPluginManager m_Instance;
|
||||
|
||||
bool m_Initialized;
|
||||
|
||||
CPluginInfos m_PluginInfos;
|
||||
|
||||
CPluginManager();
|
||||
|
||||
~CPluginManager();
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
283
Source/Core/DolphinWX/Src/PluginOptions.cpp
Normal file
283
Source/Core/DolphinWX/Src/PluginOptions.cpp
Normal file
|
|
@ -0,0 +1,283 @@
|
|||
// Copyright (C) 2003-2008 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 <string>
|
||||
#include <vector>
|
||||
|
||||
#include "Globals.h"
|
||||
|
||||
#include "PluginOptions.h"
|
||||
#include "PluginManager.h"
|
||||
|
||||
#include "Config.h"
|
||||
|
||||
BEGIN_EVENT_TABLE(CPluginOptions, wxDialog)
|
||||
|
||||
EVT_CLOSE(CPluginOptions::OnClose)
|
||||
EVT_BUTTON(ID_OK, CPluginOptions::OKClick)
|
||||
EVT_BUTTON(ID_APPLY, CPluginOptions::OKClick)
|
||||
EVT_BUTTON(ID_CANCEL, CPluginOptions::OKClick)
|
||||
EVT_CHOICE(ID_PAD_CB, CPluginOptions::OnSelectionChanged)
|
||||
EVT_CHOICE(ID_DSP_CB, CPluginOptions::OnSelectionChanged)
|
||||
EVT_CHOICE(ID_GRAPHIC_CB, CPluginOptions::OnSelectionChanged)
|
||||
EVT_BUTTON(ID_PAD_ABOUT, CPluginOptions::OnAbout)
|
||||
EVT_BUTTON(ID_DSP_ABOUT, CPluginOptions::OnAbout)
|
||||
EVT_BUTTON(ID_GRAPHIC_ABOUT, CPluginOptions::OnAbout)
|
||||
EVT_BUTTON(ID_PAD_CONFIG, CPluginOptions::OnConfig)
|
||||
EVT_BUTTON(ID_DSP_CONFIG, CPluginOptions::OnConfig)
|
||||
EVT_BUTTON(ID_GRAPHIC_CONFIG, CPluginOptions::OnConfig)
|
||||
|
||||
END_EVENT_TABLE()
|
||||
|
||||
|
||||
CPluginOptions::CPluginOptions(wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& position, const wxSize& size, long style)
|
||||
: wxDialog(parent, id, title, position, size, style)
|
||||
{
|
||||
CreateGUIControls();
|
||||
}
|
||||
|
||||
|
||||
CPluginOptions::~CPluginOptions()
|
||||
{}
|
||||
|
||||
|
||||
void CPluginOptions::CreateGUIControls()
|
||||
{
|
||||
OK = new wxButton(this, ID_OK, wxT("OK"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
|
||||
Cancel = new wxButton(this, ID_CANCEL, wxT("Cancel"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
|
||||
Apply = new wxButton(this, ID_APPLY, wxT("Apply"), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
|
||||
Apply->Disable();
|
||||
|
||||
GraphicSelection = new wxChoice(this, ID_GRAPHIC_CB, wxDefaultPosition, wxDefaultSize, NULL, 0, wxDefaultValidator);
|
||||
GraphicAbout = new wxButton(this, ID_GRAPHIC_ABOUT, wxT("About..."), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
|
||||
GraphicConfig = new wxButton(this, ID_GRAPHIC_CONFIG, wxT("Config..."), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
|
||||
GraphicText = new wxStaticText(this, ID_GRAPHIC_TEXT, wxT("GFX:"), wxDefaultPosition, wxDefaultSize);
|
||||
|
||||
FillChoiceBox(GraphicSelection, PLUGIN_TYPE_VIDEO, SConfig::GetInstance().m_LocalCoreStartupParameter.m_strVideoPlugin);
|
||||
|
||||
DSPSelection = new wxChoice(this, ID_DSP_CB, wxDefaultPosition, wxDefaultSize, NULL, 0, wxDefaultValidator);
|
||||
DSPAbout = new wxButton(this, ID_DSP_ABOUT, wxT("About..."), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
|
||||
DSPConfig = new wxButton(this, ID_DSP_CONFIG, wxT("Config..."), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
|
||||
DSPText = new wxStaticText(this, ID_DSP_TEXT, wxT("DSP:"), wxDefaultPosition, wxDefaultSize);
|
||||
|
||||
FillChoiceBox(DSPSelection, PLUGIN_TYPE_DSP, SConfig::GetInstance().m_LocalCoreStartupParameter.m_strDSPPlugin);
|
||||
|
||||
PADSelection = new wxChoice(this, ID_PAD_CB, wxDefaultPosition, wxDefaultSize, NULL, 0, wxDefaultValidator);
|
||||
PADAbout = new wxButton(this, ID_PAD_ABOUT, wxT("About..."), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
|
||||
PADConfig = new wxButton(this, ID_PAD_CONFIG, wxT("Config..."), wxDefaultPosition, wxDefaultSize, 0, wxDefaultValidator);
|
||||
PADText = new wxStaticText(this, ID_PAD_TEXT, wxT("PAD:"), wxDefaultPosition, wxDefaultSize);
|
||||
|
||||
FillChoiceBox(PADSelection, PLUGIN_TYPE_PAD, SConfig::GetInstance().m_LocalCoreStartupParameter.m_strPadPlugin);
|
||||
|
||||
wxGridBagSizer* sConfig;
|
||||
sConfig = new wxGridBagSizer(0, 0);
|
||||
sConfig->SetFlexibleDirection(wxBOTH);
|
||||
sConfig->SetNonFlexibleGrowMode(wxFLEX_GROWMODE_SPECIFIED);
|
||||
sConfig->Add(GraphicText, wxGBPosition(0, 0), wxGBSpan(2, 1), wxALIGN_CENTER_VERTICAL|wxALL, 5);
|
||||
sConfig->Add(GraphicSelection, wxGBPosition(0, 1), wxGBSpan(1, 2), wxEXPAND|wxALL, 5);
|
||||
sConfig->Add(GraphicConfig, wxGBPosition(0, 3), wxGBSpan(1, 1), wxALL, 5);
|
||||
sConfig->Add(GraphicAbout, wxGBPosition(0, 4), wxGBSpan(1, 1), wxALL, 5);
|
||||
|
||||
sConfig->Add(DSPText, wxGBPosition(2, 0), wxGBSpan(2, 1), wxALIGN_CENTER_VERTICAL|wxALL, 5);
|
||||
sConfig->Add(DSPSelection, wxGBPosition(2, 1), wxGBSpan(1, 2), wxEXPAND|wxALL, 5);
|
||||
sConfig->Add(DSPConfig, wxGBPosition(2, 3), wxGBSpan(1, 1), wxALL, 5);
|
||||
sConfig->Add(DSPAbout, wxGBPosition(2, 4), wxGBSpan(1, 1), wxALL, 5);
|
||||
|
||||
sConfig->Add(PADText, wxGBPosition(4, 0), wxGBSpan(2, 1), wxALIGN_CENTER_VERTICAL|wxALL, 5);
|
||||
sConfig->Add(PADSelection, wxGBPosition(4, 1), wxGBSpan(1, 2), wxEXPAND|wxALL, 5);
|
||||
sConfig->Add(PADConfig, wxGBPosition(4, 3), wxGBSpan(1, 1), wxALL, 5);
|
||||
sConfig->Add(PADAbout, wxGBPosition(4, 4), wxGBSpan(1, 1), wxALL, 5);
|
||||
sConfig->Layout();
|
||||
|
||||
wxBoxSizer* sButtons;
|
||||
sButtons = new wxBoxSizer(wxHORIZONTAL);
|
||||
sButtons->Add(0, 0, 1, wxEXPAND, 5);
|
||||
sButtons->Add(OK, 0, wxALL, 5);
|
||||
sButtons->Add(Cancel, 0, wxALL, 5);
|
||||
sButtons->Add(Apply, 0, wxALL, 5);
|
||||
|
||||
wxBoxSizer* sMain;
|
||||
sMain = new wxBoxSizer(wxVERTICAL);
|
||||
sMain->Add(sConfig, 1, wxEXPAND|wxALL, 5);
|
||||
sMain->Add(sButtons, 0, wxEXPAND, 5);
|
||||
|
||||
Center();
|
||||
this->SetSizer(sMain);
|
||||
sMain->SetSizeHints(this);
|
||||
}
|
||||
|
||||
|
||||
void CPluginOptions::OnClose(wxCloseEvent& WXUNUSED (event))
|
||||
{
|
||||
Destroy();
|
||||
}
|
||||
|
||||
|
||||
void CPluginOptions::OKClick(wxCommandEvent& event)
|
||||
{
|
||||
switch (event.GetId())
|
||||
{
|
||||
case ID_OK:
|
||||
DoApply();
|
||||
Destroy();
|
||||
break;
|
||||
|
||||
case ID_APPLY:
|
||||
DoApply();
|
||||
break;
|
||||
|
||||
case ID_CANCEL:
|
||||
Destroy();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void CPluginOptions::OnSelectionChanged(wxCommandEvent& WXUNUSED (event))
|
||||
{
|
||||
Apply->Enable();
|
||||
}
|
||||
|
||||
|
||||
void CPluginOptions::OnAbout(wxCommandEvent& event)
|
||||
{
|
||||
switch (event.GetId())
|
||||
{
|
||||
case ID_PAD_ABOUT:
|
||||
CallAbout(PADSelection);
|
||||
break;
|
||||
|
||||
case ID_DSP_ABOUT:
|
||||
CallAbout(DSPSelection);
|
||||
break;
|
||||
|
||||
case ID_GRAPHIC_ABOUT:
|
||||
CallAbout(GraphicSelection);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void CPluginOptions::OnConfig(wxCommandEvent& event)
|
||||
{
|
||||
switch (event.GetId())
|
||||
{
|
||||
case ID_PAD_CONFIG:
|
||||
CallConfig(PADSelection);
|
||||
break;
|
||||
|
||||
case ID_DSP_CONFIG:
|
||||
CallConfig(DSPSelection);
|
||||
break;
|
||||
|
||||
case ID_GRAPHIC_CONFIG:
|
||||
CallConfig(GraphicSelection);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void CPluginOptions::FillChoiceBox(wxChoice* _pChoice, int _PluginType, const std::string& _SelectFilename)
|
||||
{
|
||||
_pChoice->Clear();
|
||||
|
||||
int Index = -1;
|
||||
const CPluginInfos& rInfos = CPluginManager::GetInstance().GetPluginInfos();
|
||||
|
||||
for (size_t i = 0; i < rInfos.size(); i++)
|
||||
{
|
||||
const PLUGIN_INFO& rPluginInfo = rInfos[i].GetPluginInfo();
|
||||
|
||||
if (rPluginInfo.Type == _PluginType)
|
||||
{
|
||||
wxString temp;
|
||||
temp = wxString::FromAscii(rInfos[i].GetPluginInfo().Name);
|
||||
int NewIndex = _pChoice->Append(temp, (void*)&rInfos[i]);
|
||||
|
||||
if (rInfos[i].GetFileName() == _SelectFilename)
|
||||
{
|
||||
Index = NewIndex;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
_pChoice->Select(Index);
|
||||
}
|
||||
|
||||
|
||||
void CPluginOptions::CallConfig(wxChoice* _pChoice)
|
||||
{
|
||||
int Index = _pChoice->GetSelection();
|
||||
|
||||
if (Index >= 0)
|
||||
{
|
||||
const CPluginInfo* pInfo = static_cast<CPluginInfo*>(_pChoice->GetClientData(Index));
|
||||
|
||||
if (pInfo != NULL)
|
||||
{
|
||||
CPluginManager::GetInstance().OpenConfig((HWND) this->GetHandle(), pInfo->GetFileName());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void CPluginOptions::CallAbout(wxChoice* _pChoice)
|
||||
{
|
||||
int Index = _pChoice->GetSelection();
|
||||
|
||||
if (Index >= 0)
|
||||
{
|
||||
const CPluginInfo* pInfo = static_cast<CPluginInfo*>(_pChoice->GetClientData(Index));
|
||||
|
||||
if (pInfo != NULL)
|
||||
{
|
||||
CPluginManager::GetInstance().OpenAbout((HWND) this->GetHandle(), pInfo->GetFileName());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void CPluginOptions::DoApply()
|
||||
{
|
||||
Apply->Disable();
|
||||
|
||||
GetFilename(GraphicSelection, SConfig::GetInstance().m_LocalCoreStartupParameter.m_strVideoPlugin);
|
||||
GetFilename(DSPSelection, SConfig::GetInstance().m_LocalCoreStartupParameter.m_strDSPPlugin);
|
||||
GetFilename(PADSelection, SConfig::GetInstance().m_LocalCoreStartupParameter.m_strPadPlugin);
|
||||
|
||||
SConfig::GetInstance().SaveSettings();
|
||||
}
|
||||
|
||||
|
||||
bool CPluginOptions::GetFilename(wxChoice* _pChoice, std::string& _rFilename)
|
||||
{
|
||||
_rFilename.clear();
|
||||
|
||||
int Index = _pChoice->GetSelection();
|
||||
printf("%i\n", Index);
|
||||
|
||||
if (Index >= 0)
|
||||
{
|
||||
const CPluginInfo* pInfo = static_cast<CPluginInfo*>(_pChoice->GetClientData(Index));
|
||||
_rFilename = pInfo->GetFileName();
|
||||
printf("%s\n", _rFilename.c_str());
|
||||
return(true);
|
||||
}
|
||||
|
||||
return(false);
|
||||
}
|
||||
|
||||
109
Source/Core/DolphinWX/Src/PluginOptions.h
Normal file
109
Source/Core/DolphinWX/Src/PluginOptions.h
Normal file
|
|
@ -0,0 +1,109 @@
|
|||
// Copyright (C) 2003-2008 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/
|
||||
|
||||
#ifndef __PLUGIN_OPTIONS_h__
|
||||
#define __PLUGIN_OPTIONS_h__
|
||||
|
||||
#include <wx/gbsizer.h>
|
||||
|
||||
#undef PLUGIN_OPTIONS_STYLE
|
||||
#define PLUGIN_OPTIONS_STYLE wxCAPTION | wxSYSTEM_MENU | wxDIALOG_NO_PARENT | wxMINIMIZE_BOX | wxCLOSE_BOX
|
||||
|
||||
class CPluginOptions
|
||||
: public wxDialog
|
||||
{
|
||||
private:
|
||||
|
||||
DECLARE_EVENT_TABLE();
|
||||
|
||||
public:
|
||||
|
||||
CPluginOptions(wxWindow* parent, wxWindowID id = 1, const wxString& title = wxT("Plugin Selection"), const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = PLUGIN_OPTIONS_STYLE);
|
||||
virtual ~CPluginOptions();
|
||||
void OKClick(wxCommandEvent& event);
|
||||
void OnSelectionChanged(wxCommandEvent& event);
|
||||
void OnAbout(wxCommandEvent& event);
|
||||
void OnConfig(wxCommandEvent& event);
|
||||
|
||||
|
||||
private:
|
||||
|
||||
//Do not add custom control declarations between
|
||||
//GUI Control Declaration Start and GUI Control Declaration End.
|
||||
//wxDev-C++ will remove them. Add custom code after the block.
|
||||
////GUI Control Declaration Start
|
||||
wxButton* OK;
|
||||
wxButton* Cancel;
|
||||
wxButton* Apply;
|
||||
wxStaticText* PADText;
|
||||
wxButton* PADAbout;
|
||||
wxButton* PADConfig;
|
||||
wxChoice* PADSelection;
|
||||
wxButton* DSPAbout;
|
||||
wxButton* DSPConfig;
|
||||
wxStaticText* DSPText;
|
||||
wxChoice* DSPSelection;
|
||||
wxButton* GraphicAbout;
|
||||
wxButton* GraphicConfig;
|
||||
wxStaticText* GraphicText;
|
||||
wxChoice* GraphicSelection;
|
||||
////GUI Control Declaration End
|
||||
|
||||
private:
|
||||
|
||||
//Note: if you receive any error with these enum IDs, then you need to
|
||||
//change your old form code that are based on the #define control IDs.
|
||||
//#defines may replace a numeric value for the enum names.
|
||||
//Try copy and pasting the below block in your old form header files.
|
||||
enum
|
||||
{
|
||||
////GUI Enum Control ID Start
|
||||
ID_CANCEL = 1034,
|
||||
ID_APPLY = 1033,
|
||||
ID_OK = 1032,
|
||||
ID_PAD_TEXT = 1031,
|
||||
ID_PAD_ABOUT = 1030,
|
||||
ID_PAD_CONFIG = 1029,
|
||||
ID_PAD_CB = 1028,
|
||||
ID_DSP_ABOUT = 1027,
|
||||
ID_DSP_CONFIG = 1026,
|
||||
ID_DSP_TEXT = 1025,
|
||||
ID_DSP_CB = 1024,
|
||||
ID_GRAPHIC_ABOUT = 1007,
|
||||
ID_GRAPHIC_CONFIG = 1006,
|
||||
ID_GRAPHIC_TEXT = 1005,
|
||||
ID_GRAPHIC_CB = 1003,
|
||||
////GUI Enum Control ID End
|
||||
ID_DUMMY_VALUE_ //don't remove this value unless you have other enum values
|
||||
};
|
||||
|
||||
private:
|
||||
|
||||
void OnClose(wxCloseEvent& event);
|
||||
void CreateGUIControls();
|
||||
|
||||
void FillChoiceBox(wxChoice* _pChoice, int _PluginType, const std::string& _SelectFilename);
|
||||
|
||||
void CallConfig(wxChoice* _pChoice);
|
||||
void CallAbout(wxChoice* _pChoice);
|
||||
|
||||
void DoApply();
|
||||
|
||||
bool GetFilename(wxChoice* _pChoice, std::string& _rFilename);
|
||||
};
|
||||
|
||||
#endif
|
||||
69
Source/Core/DolphinWX/Src/SConscript
Normal file
69
Source/Core/DolphinWX/Src/SConscript
Normal file
|
|
@ -0,0 +1,69 @@
|
|||
Import('env')
|
||||
import sys
|
||||
|
||||
files = [
|
||||
'BootManager.cpp',
|
||||
'Config.cpp',
|
||||
'FileSearch.cpp',
|
||||
'Frame.cpp',
|
||||
'GameListCtrl.cpp',
|
||||
'Globals.cpp',
|
||||
'ISOFile.cpp',
|
||||
'MemcardManager.cpp',
|
||||
'MemoryCards/GCMemcard.cpp',
|
||||
'PluginManager.cpp',
|
||||
'PluginOptions.cpp',
|
||||
'stdafx.cpp',
|
||||
'cmdline.c',
|
||||
]
|
||||
libs = [
|
||||
'debwx', 'core', 'discio', 'bdisasm', 'videocommon', 'common', 'z'
|
||||
]
|
||||
|
||||
wxenv = env.Copy()
|
||||
wxenv.Append(
|
||||
CXXFLAGS = ' ' + ' '.join([
|
||||
'`wx-config --cppflags`',
|
||||
'-DUSE_XPM_BITMAPS',
|
||||
'-DwxNEEDS_CHARPP',
|
||||
'`sdl-config --cflags`',
|
||||
]),
|
||||
LINKFLAGS = ' ' + ' '.join([
|
||||
'-L/usr/local/lib',
|
||||
'-pthread',
|
||||
'`wx-config --libs`',
|
||||
'`sdl-config --libs`'
|
||||
])
|
||||
)
|
||||
|
||||
if sys.platform == 'darwin':
|
||||
exeGUI = '../../../../Binary/mac/Dolphin.app/Contents/MacOS/Dolphin'
|
||||
exeNoGUI = '../../../../Binary/mac/DolphinNoGUI'
|
||||
|
||||
icon = 'Dolphin'
|
||||
version = 'svn'
|
||||
wxenv.Plist(
|
||||
'../../../../Binary/mac/Dolphin.app/Contents/Info.plist',
|
||||
Value(dict(
|
||||
CFAppleHelpAnchor = 'index',
|
||||
CFBundleExecutable = 'Dolphin',
|
||||
CFBundleGetInfoHTML = 'Dolphin ' + version,
|
||||
CFBundleIconFile = icon,
|
||||
CFBundleIdentifier = 'com.dolphin-emu.dolphin',
|
||||
CFBundleName = 'Dolphin',
|
||||
CFBundlePackageType = 'APPL',
|
||||
CFBundleShortVersionString = version,
|
||||
CFBundleSignature = 'dlfn',
|
||||
CFBundleVersion = version,
|
||||
LSRequiresCarbon = True,
|
||||
NSPrefPaneIconFile = icon,
|
||||
NSPrefPaneIconLabel = 'Dolphin',
|
||||
))
|
||||
)
|
||||
else:
|
||||
exeGUI = '../../../../Binary/linux/Dolphin'
|
||||
exeNoGUI = '../../../../Binary/linux/DolphinNoGUI'
|
||||
|
||||
objects = [ wxenv.Object(srcFile) for srcFile in files ]
|
||||
wxenv.Program(exeGUI, objects + [ 'Main.cpp' ], LIBS = libs)
|
||||
wxenv.Program(exeNoGUI, objects + [ 'MainNoGUI.cpp' ], LIBS = libs)
|
||||
365
Source/Core/DolphinWX/Src/cmdline.c
Normal file
365
Source/Core/DolphinWX/Src/cmdline.c
Normal file
|
|
@ -0,0 +1,365 @@
|
|||
/*
|
||||
File autogenerated by gengetopt version 2.21
|
||||
generated with the following command:
|
||||
gengetopt --unamed-opt=ISOFILE -i Params.ggo
|
||||
|
||||
The developers of gengetopt consider the fixed text that goes in all
|
||||
gengetopt output files to be in the public domain:
|
||||
we make no copyright claims on it.
|
||||
*/
|
||||
|
||||
/* If we use autoconf. */
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "getopt.h"
|
||||
|
||||
#include "cmdline.h"
|
||||
|
||||
const char *gengetopt_args_info_purpose = "A multi platform gamecube/wii emulator";
|
||||
|
||||
const char *gengetopt_args_info_usage = "Usage: Dolphin [OPTIONS]... [ISOFILE]...";
|
||||
|
||||
const char *gengetopt_args_info_description = "";
|
||||
|
||||
const char *gengetopt_args_info_help[] = {
|
||||
" -h, --help Print help and exit",
|
||||
" -V, --version Print version and exit",
|
||||
" -d, --debug enable debug (default=off)",
|
||||
0
|
||||
};
|
||||
|
||||
static
|
||||
void clear_given (struct gengetopt_args_info *args_info);
|
||||
static
|
||||
void clear_args (struct gengetopt_args_info *args_info);
|
||||
|
||||
static int
|
||||
cmdline_parser_internal (int argc, char * const *argv, struct gengetopt_args_info *args_info,
|
||||
struct cmdline_parser_params *params, const char *additional_error);
|
||||
|
||||
|
||||
static char *
|
||||
gengetopt_strdup (const char *s);
|
||||
|
||||
static
|
||||
void clear_given (struct gengetopt_args_info *args_info)
|
||||
{
|
||||
args_info->help_given = 0 ;
|
||||
args_info->version_given = 0 ;
|
||||
args_info->debug_given = 0 ;
|
||||
}
|
||||
|
||||
static
|
||||
void clear_args (struct gengetopt_args_info *args_info)
|
||||
{
|
||||
args_info->debug_flag = 0;
|
||||
|
||||
}
|
||||
|
||||
static
|
||||
void init_args_info(struct gengetopt_args_info *args_info)
|
||||
{
|
||||
args_info->help_help = gengetopt_args_info_help[0] ;
|
||||
args_info->version_help = gengetopt_args_info_help[1] ;
|
||||
args_info->debug_help = gengetopt_args_info_help[2] ;
|
||||
|
||||
}
|
||||
|
||||
void
|
||||
cmdline_parser_print_version (void)
|
||||
{
|
||||
printf ("%s %s\n", CMDLINE_PARSER_PACKAGE, CMDLINE_PARSER_VERSION);
|
||||
}
|
||||
|
||||
void
|
||||
cmdline_parser_print_help (void)
|
||||
{
|
||||
int i = 0;
|
||||
cmdline_parser_print_version ();
|
||||
|
||||
if (strlen(gengetopt_args_info_purpose) > 0)
|
||||
printf("\n%s\n", gengetopt_args_info_purpose);
|
||||
|
||||
printf("\n%s\n\n", gengetopt_args_info_usage);
|
||||
|
||||
if (strlen(gengetopt_args_info_description) > 0)
|
||||
printf("%s\n", gengetopt_args_info_description);
|
||||
|
||||
while (gengetopt_args_info_help[i])
|
||||
printf("%s\n", gengetopt_args_info_help[i++]);
|
||||
}
|
||||
|
||||
void
|
||||
cmdline_parser_init (struct gengetopt_args_info *args_info)
|
||||
{
|
||||
clear_given (args_info);
|
||||
clear_args (args_info);
|
||||
init_args_info (args_info);
|
||||
|
||||
args_info->inputs = NULL;
|
||||
args_info->inputs_num = 0;
|
||||
}
|
||||
|
||||
struct cmdline_parser_params *
|
||||
cmdline_parser_params_init()
|
||||
{
|
||||
struct cmdline_parser_params *params =
|
||||
(struct cmdline_parser_params *)malloc(sizeof(struct cmdline_parser_params));
|
||||
|
||||
if (params)
|
||||
{
|
||||
params->override = 0;
|
||||
params->initialize = 0;
|
||||
params->check_required = 0;
|
||||
params->check_ambiguity = 0;
|
||||
}
|
||||
|
||||
return params;
|
||||
}
|
||||
|
||||
static void
|
||||
cmdline_parser_release (struct gengetopt_args_info *args_info)
|
||||
{
|
||||
|
||||
unsigned int i;
|
||||
|
||||
for (i = 0; i < args_info->inputs_num; ++i)
|
||||
free (args_info->inputs [i]);
|
||||
|
||||
if (args_info->inputs_num)
|
||||
free (args_info->inputs);
|
||||
|
||||
clear_given (args_info);
|
||||
}
|
||||
|
||||
int
|
||||
cmdline_parser_file_save(const char *filename, struct gengetopt_args_info *args_info)
|
||||
{
|
||||
FILE *outfile;
|
||||
int i = 0;
|
||||
|
||||
outfile = fopen(filename, "w");
|
||||
|
||||
if (!outfile)
|
||||
{
|
||||
fprintf (stderr, "%s: cannot open file for writing: %s\n", CMDLINE_PARSER_PACKAGE, filename);
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
|
||||
if (args_info->help_given) {
|
||||
fprintf(outfile, "%s\n", "help");
|
||||
}
|
||||
if (args_info->version_given) {
|
||||
fprintf(outfile, "%s\n", "version");
|
||||
}
|
||||
if (args_info->debug_given) {
|
||||
fprintf(outfile, "%s\n", "debug");
|
||||
}
|
||||
|
||||
fclose (outfile);
|
||||
|
||||
i = EXIT_SUCCESS;
|
||||
return i;
|
||||
}
|
||||
|
||||
void
|
||||
cmdline_parser_free (struct gengetopt_args_info *args_info)
|
||||
{
|
||||
cmdline_parser_release (args_info);
|
||||
}
|
||||
|
||||
|
||||
/* gengetopt_strdup() */
|
||||
/* strdup.c replacement of strdup, which is not standard */
|
||||
char *
|
||||
gengetopt_strdup (const char *s)
|
||||
{
|
||||
char *result = NULL;
|
||||
if (!s)
|
||||
return result;
|
||||
|
||||
result = (char*)malloc(strlen(s) + 1);
|
||||
if (result == (char*)0)
|
||||
return (char*)0;
|
||||
strcpy(result, s);
|
||||
return result;
|
||||
}
|
||||
|
||||
int
|
||||
cmdline_parser (int argc, char * const *argv, struct gengetopt_args_info *args_info)
|
||||
{
|
||||
return cmdline_parser2 (argc, argv, args_info, 0, 1, 1);
|
||||
}
|
||||
|
||||
int
|
||||
cmdline_parser_ext (int argc, char * const *argv, struct gengetopt_args_info *args_info,
|
||||
struct cmdline_parser_params *params)
|
||||
{
|
||||
int result;
|
||||
result = cmdline_parser_internal (argc, argv, args_info, params, NULL);
|
||||
|
||||
if (result == EXIT_FAILURE)
|
||||
{
|
||||
cmdline_parser_free (args_info);
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
int
|
||||
cmdline_parser2 (int argc, char * const *argv, struct gengetopt_args_info *args_info, int override, int initialize, int check_required)
|
||||
{
|
||||
int result;
|
||||
struct cmdline_parser_params params;
|
||||
|
||||
params.override = override;
|
||||
params.initialize = initialize;
|
||||
params.check_required = check_required;
|
||||
params.check_ambiguity = 0;
|
||||
|
||||
result = cmdline_parser_internal (argc, argv, args_info, ¶ms, NULL);
|
||||
|
||||
if (result == EXIT_FAILURE)
|
||||
{
|
||||
cmdline_parser_free (args_info);
|
||||
exit (EXIT_FAILURE);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
int
|
||||
cmdline_parser_required (struct gengetopt_args_info *args_info, const char *prog_name)
|
||||
{
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
int
|
||||
cmdline_parser_internal (int argc, char * const *argv, struct gengetopt_args_info *args_info,
|
||||
struct cmdline_parser_params *params, const char *additional_error)
|
||||
{
|
||||
int c; /* Character of the parsed option. */
|
||||
|
||||
int error = 0;
|
||||
struct gengetopt_args_info local_args_info;
|
||||
|
||||
int override;
|
||||
int initialize;
|
||||
int check_required;
|
||||
int check_ambiguity;
|
||||
|
||||
override = params->override;
|
||||
initialize = params->initialize;
|
||||
check_required = params->check_required;
|
||||
check_ambiguity = params->check_ambiguity;
|
||||
|
||||
if (initialize)
|
||||
cmdline_parser_init (args_info);
|
||||
|
||||
cmdline_parser_init (&local_args_info);
|
||||
|
||||
optarg = 0;
|
||||
optind = 0;
|
||||
opterr = 1;
|
||||
optopt = '?';
|
||||
|
||||
while (1)
|
||||
{
|
||||
int option_index = 0;
|
||||
char *stop_char;
|
||||
|
||||
static struct option long_options[] = {
|
||||
{ "help", 0, NULL, 'h' },
|
||||
{ "version", 0, NULL, 'V' },
|
||||
{ "debug", 0, NULL, 'd' },
|
||||
{ NULL, 0, NULL, 0 }
|
||||
};
|
||||
|
||||
stop_char = 0;
|
||||
c = getopt_long (argc, argv, "hVd", long_options, &option_index);
|
||||
|
||||
if (c == -1) break; /* Exit from `while (1)' loop. */
|
||||
|
||||
switch (c)
|
||||
{
|
||||
case 'h': /* Print help and exit. */
|
||||
cmdline_parser_print_help ();
|
||||
cmdline_parser_free (&local_args_info);
|
||||
exit (EXIT_SUCCESS);
|
||||
|
||||
case 'V': /* Print version and exit. */
|
||||
cmdline_parser_print_version ();
|
||||
cmdline_parser_free (&local_args_info);
|
||||
exit (EXIT_SUCCESS);
|
||||
|
||||
case 'd': /* enable debug. */
|
||||
if (local_args_info.debug_given || (check_ambiguity && args_info->debug_given))
|
||||
{
|
||||
fprintf (stderr, "%s: `--debug' (`-d') option given more than once%s\n", argv[0], (additional_error ? additional_error : ""));
|
||||
goto failure;
|
||||
}
|
||||
if (args_info->debug_given && ! override)
|
||||
continue;
|
||||
local_args_info.debug_given = 1;
|
||||
args_info->debug_given = 1;
|
||||
args_info->debug_flag = !(args_info->debug_flag);
|
||||
break;
|
||||
|
||||
|
||||
case 0: /* Long option with no short option */
|
||||
case '?': /* Invalid option. */
|
||||
/* `getopt_long' already printed an error message. */
|
||||
goto failure;
|
||||
|
||||
default: /* bug: option not considered. */
|
||||
fprintf (stderr, "%s: option unknown: %c%s\n", CMDLINE_PARSER_PACKAGE, c, (additional_error ? additional_error : ""));
|
||||
abort ();
|
||||
} /* switch */
|
||||
} /* while */
|
||||
|
||||
|
||||
|
||||
|
||||
cmdline_parser_release (&local_args_info);
|
||||
|
||||
if ( error )
|
||||
return (EXIT_FAILURE);
|
||||
|
||||
if (optind < argc)
|
||||
{
|
||||
int i = 0 ;
|
||||
int found_prog_name = 0;
|
||||
/* whether program name, i.e., argv[0], is in the remaining args
|
||||
(this may happen with some implementations of getopt,
|
||||
but surely not with the one included by gengetopt) */
|
||||
|
||||
i = optind;
|
||||
while (i < argc)
|
||||
if (argv[i++] == argv[0]) {
|
||||
found_prog_name = 1;
|
||||
break;
|
||||
}
|
||||
i = 0;
|
||||
|
||||
args_info->inputs_num = argc - optind - found_prog_name;
|
||||
args_info->inputs =
|
||||
(char **)(malloc ((args_info->inputs_num)*sizeof(char *))) ;
|
||||
while (optind < argc)
|
||||
if (argv[optind++] != argv[0])
|
||||
args_info->inputs[ i++ ] = gengetopt_strdup (argv[optind-1]) ;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
failure:
|
||||
|
||||
cmdline_parser_release (&local_args_info);
|
||||
return (EXIT_FAILURE);
|
||||
}
|
||||
152
Source/Core/DolphinWX/Src/cmdline.h
Normal file
152
Source/Core/DolphinWX/Src/cmdline.h
Normal file
|
|
@ -0,0 +1,152 @@
|
|||
/** @file cmdline.h
|
||||
* @brief The header file for the command line option parser
|
||||
* generated by GNU Gengetopt version 2.21
|
||||
* http://www.gnu.org/software/gengetopt.
|
||||
* DO NOT modify this file, since it can be overwritten
|
||||
* @author GNU Gengetopt by Lorenzo Bettini */
|
||||
|
||||
#ifndef CMDLINE_H
|
||||
#define CMDLINE_H
|
||||
|
||||
/* If we use autoconf. */
|
||||
#ifdef HAVE_CONFIG_H
|
||||
#include "config.h"
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif /* __cplusplus */
|
||||
|
||||
#ifndef CMDLINE_PARSER_PACKAGE
|
||||
/** @brief the program name */
|
||||
#define CMDLINE_PARSER_PACKAGE "Dolphin"
|
||||
#endif
|
||||
|
||||
#ifndef CMDLINE_PARSER_VERSION
|
||||
/** @brief the program version */
|
||||
#define CMDLINE_PARSER_VERSION "SVN"
|
||||
#endif
|
||||
|
||||
/** @brief Where the command line options are stored */
|
||||
struct gengetopt_args_info
|
||||
{
|
||||
const char *help_help; /**< @brief Print help and exit help description. */
|
||||
const char *version_help; /**< @brief Print version and exit help description. */
|
||||
int debug_flag; /**< @brief enable debug (default=off). */
|
||||
const char *debug_help; /**< @brief enable debug help description. */
|
||||
|
||||
int help_given ; /**< @brief Whether help was given. */
|
||||
int version_given ; /**< @brief Whether version was given. */
|
||||
int debug_given ; /**< @brief Whether debug was given. */
|
||||
|
||||
char **inputs ; /**< @brief unamed options (options without names) */
|
||||
unsigned inputs_num ; /**< @brief unamed options number */
|
||||
} ;
|
||||
|
||||
/** @brief The additional parameters to pass to parser functions */
|
||||
struct cmdline_parser_params
|
||||
{
|
||||
int override; /**< @brief whether to override possibly already present options (default 0) */
|
||||
int initialize; /**< @brief whether to initialize the option structure gengetopt_args_info (default 0) */
|
||||
int check_required; /**< @brief whether to check that all required options were provided (default 0) */
|
||||
int check_ambiguity; /**< @brief whether to check for options already specified in the option structure gengetopt_args_info (default 0) */
|
||||
} ;
|
||||
|
||||
/** @brief the purpose string of the program */
|
||||
extern const char *gengetopt_args_info_purpose;
|
||||
/** @brief the usage string of the program */
|
||||
extern const char *gengetopt_args_info_usage;
|
||||
/** @brief all the lines making the help output */
|
||||
extern const char *gengetopt_args_info_help[];
|
||||
|
||||
/**
|
||||
* The command line parser
|
||||
* @param argc the number of command line options
|
||||
* @param argv the command line options
|
||||
* @param args_info the structure where option information will be stored
|
||||
* @return 0 if everything went fine, NON 0 if an error took place
|
||||
*/
|
||||
int cmdline_parser (int argc, char * const *argv,
|
||||
struct gengetopt_args_info *args_info);
|
||||
|
||||
/**
|
||||
* The command line parser (version with additional parameters - deprecated)
|
||||
* @param argc the number of command line options
|
||||
* @param argv the command line options
|
||||
* @param args_info the structure where option information will be stored
|
||||
* @param override whether to override possibly already present options
|
||||
* @param initialize whether to initialize the option structure my_args_info
|
||||
* @param check_required whether to check that all required options were provided
|
||||
* @return 0 if everything went fine, NON 0 if an error took place
|
||||
* @deprecated use cmdline_parser_ext() instead
|
||||
*/
|
||||
int cmdline_parser2 (int argc, char * const *argv,
|
||||
struct gengetopt_args_info *args_info,
|
||||
int override, int initialize, int check_required);
|
||||
|
||||
/**
|
||||
* The command line parser (version with additional parameters)
|
||||
* @param argc the number of command line options
|
||||
* @param argv the command line options
|
||||
* @param args_info the structure where option information will be stored
|
||||
* @param params additional parameters for the parser
|
||||
* @return 0 if everything went fine, NON 0 if an error took place
|
||||
*/
|
||||
int cmdline_parser_ext (int argc, char * const *argv,
|
||||
struct gengetopt_args_info *args_info,
|
||||
struct cmdline_parser_params *params);
|
||||
|
||||
/**
|
||||
* Save the contents of the option struct into a (text) file.
|
||||
* This file can be read by the config file parser (if generated by gengetopt)
|
||||
* @param filename the file where to save
|
||||
* @param args_info the option struct to save
|
||||
* @return 0 if everything went fine, NON 0 if an error took place
|
||||
*/
|
||||
int cmdline_parser_file_save(const char *filename,
|
||||
struct gengetopt_args_info *args_info);
|
||||
|
||||
/**
|
||||
* Print the help
|
||||
*/
|
||||
void cmdline_parser_print_help(void);
|
||||
/**
|
||||
* Print the version
|
||||
*/
|
||||
void cmdline_parser_print_version(void);
|
||||
|
||||
/**
|
||||
* Allocates dynamically a cmdline_parser_params structure and initializes
|
||||
* all its fields to 0
|
||||
* @return the initialized cmdline_parser_params structure
|
||||
*/
|
||||
struct cmdline_parser_params *cmdline_parser_params_init();
|
||||
|
||||
/**
|
||||
* Initializes the passed gengetopt_args_info structure's fields
|
||||
* (also set default values for options that have a default)
|
||||
* @param args_info the structure to initialize
|
||||
*/
|
||||
void cmdline_parser_init (struct gengetopt_args_info *args_info);
|
||||
/**
|
||||
* Deallocates the string fields of the gengetopt_args_info structure
|
||||
* (but does not deallocate the structure itself)
|
||||
* @param args_info the structure to deallocate
|
||||
*/
|
||||
void cmdline_parser_free (struct gengetopt_args_info *args_info);
|
||||
|
||||
/**
|
||||
* Checks that all the required options were specified
|
||||
* @param args_info the structure to check
|
||||
* @param prog_name the name of the program that will be used to print
|
||||
* possible errors
|
||||
* @return
|
||||
*/
|
||||
int cmdline_parser_required (struct gengetopt_args_info *args_info,
|
||||
const char *prog_name);
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif /* __cplusplus */
|
||||
#endif /* CMDLINE_H */
|
||||
18
Source/Core/DolphinWX/Src/stdafx.cpp
Normal file
18
Source/Core/DolphinWX/Src/stdafx.cpp
Normal file
|
|
@ -0,0 +1,18 @@
|
|||
// Copyright (C) 2003-2008 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 "stdafx.h"
|
||||
50
Source/Core/DolphinWX/Src/stdafx.h
Normal file
50
Source/Core/DolphinWX/Src/stdafx.h
Normal file
|
|
@ -0,0 +1,50 @@
|
|||
// Copyright (C) 2003-2008 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/
|
||||
|
||||
#ifndef __STDAFX_H_
|
||||
#define __STDAFX_H_
|
||||
|
||||
#ifdef _WIN32
|
||||
|
||||
// Change these values to use different versions
|
||||
#define WINVER 0x0400
|
||||
#define _WIN32_WINNT 0x0501
|
||||
#define _WIN32_IE 0x0500
|
||||
#define _RICHEDIT_VER 0x0100
|
||||
|
||||
|
||||
#if defined _M_IX86
|
||||
|
||||
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='x86' publicKeyToken='6595b64144ccf1df' language='*'\"")
|
||||
|
||||
#elif defined _M_IA64
|
||||
|
||||
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='ia64' publicKeyToken='6595b64144ccf1df' language='*'\"")
|
||||
|
||||
#elif defined _M_X64
|
||||
|
||||
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='amd64' publicKeyToken='6595b64144ccf1df' language='*'\"")
|
||||
|
||||
#else
|
||||
|
||||
#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
Loading…
Reference in a new issue