2009-07-28 21:32:10 +00:00
|
|
|
// Copyright (C) 2003 Dolphin Project.
|
2009-02-23 06:15:48 +00:00
|
|
|
|
|
|
|
// 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/
|
|
|
|
|
|
|
|
|
2009-06-28 12:50:51 +00:00
|
|
|
/*
|
2009-06-20 11:05:52 +00:00
|
|
|
1.1 Windows
|
|
|
|
|
2009-05-13 22:23:54 +00:00
|
|
|
CFrame is the main parent window. Inside CFrame there is m_Panel which is the
|
|
|
|
parent for the rendering window (when we render to the main window). In Windows
|
|
|
|
the rendering window is created by giving CreateWindow() m_Panel->GetHandle()
|
|
|
|
as parent window and creating a new child window to m_Panel. The new child
|
|
|
|
window handle that is returned by CreateWindow() can be accessed from
|
|
|
|
Core::GetWindowHandle().
|
2009-06-28 12:50:51 +00:00
|
|
|
*/
|
2009-06-20 11:05:52 +00:00
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
|
2009-09-02 22:31:02 +00:00
|
|
|
// Why doesn't it work on windows?
|
2009-05-14 08:46:18 +00:00
|
|
|
#ifndef _WIN32
|
|
|
|
#include "Common.h"
|
|
|
|
#endif
|
|
|
|
|
2009-06-20 11:05:52 +00:00
|
|
|
#include "Setup.h" // Common
|
|
|
|
|
2009-05-13 22:49:53 +00:00
|
|
|
#if defined(HAVE_SFML) && HAVE_SFML || defined(_WIN32)
|
2009-05-13 21:50:24 +00:00
|
|
|
#include "NetWindow.h"
|
2009-05-13 22:23:54 +00:00
|
|
|
#endif
|
2009-05-13 21:50:24 +00:00
|
|
|
|
2009-06-20 11:05:52 +00:00
|
|
|
#include "Common.h" // Common
|
|
|
|
#include "FileUtil.h"
|
|
|
|
#include "FileSearch.h"
|
|
|
|
#include "Timer.h"
|
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
#include "Globals.h" // Local
|
|
|
|
#include "Frame.h"
|
|
|
|
#include "ConfigMain.h"
|
|
|
|
#include "PluginManager.h"
|
|
|
|
#include "MemcardManager.h"
|
|
|
|
#include "CheatsWindow.h"
|
2009-11-07 23:54:10 +00:00
|
|
|
#include "LuaWindow.h"
|
2009-02-23 06:15:48 +00:00
|
|
|
#include "AboutDolphin.h"
|
|
|
|
#include "GameListCtrl.h"
|
|
|
|
#include "BootManager.h"
|
2009-08-31 23:09:50 +00:00
|
|
|
#include "LogWindow.h"
|
2009-06-16 19:10:37 +00:00
|
|
|
#include "WxUtils.h"
|
2009-02-23 06:15:48 +00:00
|
|
|
|
|
|
|
#include "ConfigManager.h" // Core
|
|
|
|
#include "Core.h"
|
2009-08-08 01:39:56 +00:00
|
|
|
#include "OnFrame.h"
|
2009-12-28 19:34:19 +00:00
|
|
|
#include "HW/CPU.h"
|
|
|
|
#include "PowerPC/PowerPC.h"
|
2009-02-23 06:15:48 +00:00
|
|
|
#include "HW/DVDInterface.h"
|
2009-10-06 15:49:20 +00:00
|
|
|
#include "HW/ProcessorInterface.h"
|
2009-12-27 19:31:02 +00:00
|
|
|
#include "IPC_HLE/WII_IPC_HLE_Device_usb.h"
|
2009-02-23 06:15:48 +00:00
|
|
|
#include "State.h"
|
|
|
|
#include "VolumeHandler.h"
|
2009-02-27 23:44:15 +00:00
|
|
|
#include "NANDContentLoader.h"
|
2009-02-23 06:15:48 +00:00
|
|
|
|
|
|
|
#include <wx/datetime.h> // wxWidgets
|
|
|
|
|
|
|
|
|
|
|
|
// Resources
|
|
|
|
extern "C" {
|
|
|
|
#include "../resources/Dolphin.c" // Dolphin icon
|
|
|
|
#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_plugin_dsp.c"
|
|
|
|
#include "../resources/toolbar_plugin_gfx.c"
|
|
|
|
#include "../resources/toolbar_plugin_options.c"
|
|
|
|
#include "../resources/toolbar_plugin_pad.c"
|
|
|
|
#include "../resources/toolbar_refresh.c"
|
|
|
|
#include "../resources/toolbar_stop.c"
|
|
|
|
#include "../resources/Boomy.h" // Theme packages
|
|
|
|
#include "../resources/Vista.h"
|
|
|
|
#include "../resources/X-Plastik.h"
|
|
|
|
#include "../resources/KDE.h"
|
|
|
|
};
|
|
|
|
|
2009-12-27 19:31:02 +00:00
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
// Other Windows
|
|
|
|
wxCheatsWindow* CheatsWindow;
|
|
|
|
|
2009-09-02 21:00:45 +00:00
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
// Create menu items
|
2009-09-08 16:07:13 +00:00
|
|
|
// ---------------------
|
2009-02-23 06:15:48 +00:00
|
|
|
void CFrame::CreateMenu()
|
|
|
|
{
|
2009-09-03 05:24:30 +00:00
|
|
|
if (GetMenuBar()) GetMenuBar()->Destroy();
|
2009-04-16 02:32:21 +00:00
|
|
|
|
2009-09-03 05:24:30 +00:00
|
|
|
m_MenuBar = new wxMenuBar(wxMB_DOCKABLE);
|
2009-02-23 06:15:48 +00:00
|
|
|
|
|
|
|
// file menu
|
|
|
|
wxMenu* fileMenu = new wxMenu;
|
2009-04-16 02:32:21 +00:00
|
|
|
fileMenu->Append(wxID_OPEN, _T("&Open...\tCtrl+O"));
|
2009-02-24 07:30:10 +00:00
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
wxMenu *externalDrive = new wxMenu;
|
2009-04-16 02:32:21 +00:00
|
|
|
m_pSubMenuDrive = fileMenu->AppendSubMenu(externalDrive, _T("&Boot from DVD Drive..."));
|
2009-02-24 15:04:12 +00:00
|
|
|
|
|
|
|
drives = cdio_get_devices();
|
|
|
|
for (int i = 0; drives[i] != NULL && i < 24; i++) {
|
|
|
|
externalDrive->Append(IDM_DRIVE1 + i, wxString::FromAscii(drives[i]));
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
2009-02-24 15:04:12 +00:00
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
fileMenu->AppendSeparator();
|
|
|
|
fileMenu->Append(wxID_REFRESH, _T("&Refresh List"));
|
|
|
|
fileMenu->AppendSeparator();
|
|
|
|
fileMenu->Append(IDM_BROWSE, _T("&Browse for ISOs..."));
|
|
|
|
fileMenu->AppendSeparator();
|
2009-06-29 09:24:39 +00:00
|
|
|
fileMenu->Append(wxID_EXIT, _T("E&xit\tAlt+F4"));
|
2009-09-03 05:24:30 +00:00
|
|
|
m_MenuBar->Append(fileMenu, _T("&File"));
|
2009-02-23 06:15:48 +00:00
|
|
|
|
|
|
|
// Emulation menu
|
|
|
|
wxMenu* emulationMenu = new wxMenu;
|
2009-06-29 09:24:39 +00:00
|
|
|
emulationMenu->Append(IDM_PLAY, _T("&Play\tF10"));
|
2009-04-16 02:32:21 +00:00
|
|
|
emulationMenu->Append(IDM_STOP, _T("&Stop"));
|
2009-10-06 15:49:20 +00:00
|
|
|
emulationMenu->Append(IDM_RESET, _T("&Reset"));
|
2009-08-21 19:55:03 +00:00
|
|
|
emulationMenu->AppendSeparator();
|
2009-10-06 15:49:20 +00:00
|
|
|
emulationMenu->Append(IDM_RECORD, _T("Start Re&cording..."));
|
2009-08-21 19:55:03 +00:00
|
|
|
emulationMenu->Append(IDM_PLAYRECORD, _T("P&lay Recording..."));
|
|
|
|
emulationMenu->AppendSeparator();
|
|
|
|
emulationMenu->Append(IDM_CHANGEDISC, _T("Change &Disc"));
|
|
|
|
|
2009-08-22 02:05:02 +00:00
|
|
|
emulationMenu->Append(IDM_FRAMESTEP, _T("&Frame Stepping"), wxEmptyString, wxITEM_CHECK);
|
|
|
|
|
2009-08-08 01:39:56 +00:00
|
|
|
wxMenu *skippingMenu = new wxMenu;
|
2009-08-22 02:05:02 +00:00
|
|
|
m_pSubMenuFrameSkipping = emulationMenu->AppendSubMenu(skippingMenu, _T("Frame S&kipping"));
|
2009-08-08 01:39:56 +00:00
|
|
|
for(int i = 0; i < 10; i++)
|
|
|
|
skippingMenu->Append(IDM_FRAMESKIP0 + i, wxString::Format(_T("%i"), i), wxEmptyString, wxITEM_RADIO);
|
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
emulationMenu->AppendSeparator();
|
2009-06-29 09:24:39 +00:00
|
|
|
emulationMenu->Append(IDM_SCREENSHOT, _T("Take S&creenshot\tF9"));
|
|
|
|
emulationMenu->AppendSeparator();
|
2009-02-23 06:15:48 +00:00
|
|
|
wxMenu *saveMenu = new wxMenu;
|
|
|
|
wxMenu *loadMenu = new wxMenu;
|
2009-06-28 01:11:35 +00:00
|
|
|
m_pSubMenuLoad = emulationMenu->AppendSubMenu(loadMenu, _T("&Load State"));
|
|
|
|
m_pSubMenuSave = emulationMenu->AppendSubMenu(saveMenu, _T("Sa&ve State"));
|
|
|
|
|
|
|
|
saveMenu->Append(IDM_SAVESTATEFILE, _T("Save State..."));
|
2009-06-28 21:11:51 +00:00
|
|
|
loadMenu->Append(IDM_UNDOSAVESTATE, _T("Last Overwritten State\tShift+F12"));
|
2009-06-28 01:11:35 +00:00
|
|
|
saveMenu->AppendSeparator();
|
|
|
|
|
|
|
|
loadMenu->Append(IDM_LOADSTATEFILE, _T("Load State..."));
|
|
|
|
loadMenu->Append(IDM_LOADLASTSTATE, _T("Last Saved State\tF11"));
|
2009-06-28 21:11:51 +00:00
|
|
|
loadMenu->Append(IDM_UNDOLOADSTATE, _T("Undo Load State\tF12"));
|
2009-06-28 01:11:35 +00:00
|
|
|
loadMenu->AppendSeparator();
|
|
|
|
|
2009-06-28 19:47:02 +00:00
|
|
|
for (int i = 1; i <= 8; i++) {
|
2009-06-28 01:11:35 +00:00
|
|
|
loadMenu->Append(IDM_LOADSLOT1 + i - 1, wxString::Format(_T("Slot %i\tF%i"), i, i));
|
|
|
|
saveMenu->Append(IDM_SAVESLOT1 + i - 1, wxString::Format(_T("Slot %i\tShift+F%i"), i, i));
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
2009-09-03 05:24:30 +00:00
|
|
|
m_MenuBar->Append(emulationMenu, _T("&Emulation"));
|
2009-02-23 06:15:48 +00:00
|
|
|
|
|
|
|
// Options menu
|
|
|
|
wxMenu* pOptionsMenu = new wxMenu;
|
2009-04-16 02:32:21 +00:00
|
|
|
pOptionsMenu->Append(IDM_CONFIG_MAIN, _T("Co&nfigure..."));
|
2009-02-23 06:15:48 +00:00
|
|
|
pOptionsMenu->AppendSeparator();
|
|
|
|
pOptionsMenu->Append(IDM_CONFIG_GFX_PLUGIN, _T("&Graphics Settings"));
|
|
|
|
pOptionsMenu->Append(IDM_CONFIG_DSP_PLUGIN, _T("&DSP Settings"));
|
|
|
|
pOptionsMenu->Append(IDM_CONFIG_PAD_PLUGIN, _T("&Pad Settings"));
|
|
|
|
pOptionsMenu->Append(IDM_CONFIG_WIIMOTE_PLUGIN, _T("&Wiimote Settings"));
|
2009-08-31 21:46:29 +00:00
|
|
|
pOptionsMenu->AppendSeparator();
|
2009-09-03 06:54:46 +00:00
|
|
|
pOptionsMenu->Append(IDM_TOGGLE_FULLSCREEN, _T("&Fullscreen\tAlt+Enter"));
|
2009-09-07 12:40:43 +00:00
|
|
|
if (g_pCodeWindow)
|
2009-09-03 06:54:46 +00:00
|
|
|
{
|
|
|
|
pOptionsMenu->AppendSeparator();
|
|
|
|
g_pCodeWindow->CreateMenuOptions(NULL, pOptionsMenu);
|
|
|
|
}
|
2009-09-03 05:24:30 +00:00
|
|
|
m_MenuBar->Append(pOptionsMenu, _T("&Options"));
|
2009-02-23 06:15:48 +00:00
|
|
|
|
2009-03-02 21:58:56 +00:00
|
|
|
// Tools menu
|
|
|
|
wxMenu* toolsMenu = new wxMenu;
|
2009-11-07 23:54:10 +00:00
|
|
|
toolsMenu->Append(IDM_LUA, _T("New &Lua Console"));
|
2009-03-02 21:58:56 +00:00
|
|
|
toolsMenu->Append(IDM_MEMCARD, _T("&Memcard Manager"));
|
|
|
|
toolsMenu->Append(IDM_CHEATS, _T("Action &Replay Manager"));
|
2009-05-13 21:50:24 +00:00
|
|
|
|
2009-07-15 15:09:20 +00:00
|
|
|
#if defined(HAVE_SFML) && HAVE_SFML
|
2009-05-13 21:50:24 +00:00
|
|
|
toolsMenu->Append(IDM_NETPLAY, _T("Start &NetPlay"));
|
2009-07-15 15:09:20 +00:00
|
|
|
#endif
|
2009-04-28 02:30:50 +00:00
|
|
|
|
|
|
|
if (DiscIO::CNANDContentManager::Access().GetNANDLoader(FULL_WII_MENU_DIR).IsValid())
|
|
|
|
{
|
|
|
|
toolsMenu->Append(IDM_LOAD_WII_MENU, _T("Load Wii Menu"));
|
|
|
|
}
|
2009-12-27 19:31:02 +00:00
|
|
|
toolsMenu->AppendSeparator();
|
|
|
|
toolsMenu->AppendCheckItem(IDM_CONNECT_WIIMOTE1, _T("Connect Wiimote 1"));
|
|
|
|
toolsMenu->AppendCheckItem(IDM_CONNECT_WIIMOTE2, _T("Connect Wiimote 2"));
|
|
|
|
toolsMenu->AppendCheckItem(IDM_CONNECT_WIIMOTE3, _T("Connect Wiimote 3"));
|
|
|
|
toolsMenu->AppendCheckItem(IDM_CONNECT_WIIMOTE4, _T("Connect Wiimote 4"));
|
2009-02-27 23:44:15 +00:00
|
|
|
|
2009-09-03 05:24:30 +00:00
|
|
|
m_MenuBar->Append(toolsMenu, _T("&Tools"));
|
2009-02-23 06:15:48 +00:00
|
|
|
|
2009-04-28 02:30:50 +00:00
|
|
|
wxMenu* viewMenu = new wxMenu;
|
|
|
|
viewMenu->AppendCheckItem(IDM_TOGGLE_TOOLBAR, _T("Show &Toolbar"));
|
|
|
|
viewMenu->Check(IDM_TOGGLE_TOOLBAR, SConfig::GetInstance().m_InterfaceToolbar);
|
|
|
|
viewMenu->AppendCheckItem(IDM_TOGGLE_STATUSBAR, _T("Show &Statusbar"));
|
|
|
|
viewMenu->Check(IDM_TOGGLE_STATUSBAR, SConfig::GetInstance().m_InterfaceStatusbar);
|
2009-09-03 06:54:46 +00:00
|
|
|
viewMenu->AppendSeparator();
|
2009-08-31 23:09:50 +00:00
|
|
|
viewMenu->AppendCheckItem(IDM_LOGWINDOW, _T("Show &Logwindow"));
|
2009-09-01 14:33:16 +00:00
|
|
|
viewMenu->Check(IDM_LOGWINDOW, SConfig::GetInstance().m_InterfaceLogWindow);
|
2009-08-27 19:38:35 +00:00
|
|
|
viewMenu->AppendCheckItem(IDM_CONSOLEWINDOW, _T("Show &Console"));
|
|
|
|
viewMenu->Check(IDM_CONSOLEWINDOW, SConfig::GetInstance().m_InterfaceConsole);
|
2009-04-28 02:30:50 +00:00
|
|
|
viewMenu->AppendSeparator();
|
|
|
|
|
2009-09-07 12:40:43 +00:00
|
|
|
if (g_pCodeWindow)
|
2009-09-03 06:54:46 +00:00
|
|
|
{
|
|
|
|
g_pCodeWindow->CreateMenuView(NULL, viewMenu);
|
|
|
|
viewMenu->AppendSeparator();
|
|
|
|
}
|
|
|
|
|
2009-09-15 21:35:32 +00:00
|
|
|
wxMenu *platformMenu = new wxMenu;
|
|
|
|
viewMenu->AppendSubMenu(platformMenu, _T("Show Platforms"));
|
|
|
|
platformMenu->AppendCheckItem(IDM_LISTWII, _T("Show Wii"));
|
|
|
|
platformMenu->Check(IDM_LISTWII, SConfig::GetInstance().m_ListWii);
|
|
|
|
platformMenu->AppendCheckItem(IDM_LISTGC, _T("Show GameCube"));
|
|
|
|
platformMenu->Check(IDM_LISTGC, SConfig::GetInstance().m_ListGC);
|
|
|
|
platformMenu->AppendCheckItem(IDM_LISTWAD, _T("Show Wad"));
|
|
|
|
platformMenu->Check(IDM_LISTWAD, SConfig::GetInstance().m_ListWad);
|
|
|
|
|
|
|
|
wxMenu *regionMenu = new wxMenu;
|
|
|
|
viewMenu->AppendSubMenu(regionMenu, _T("Show Regions"));
|
|
|
|
regionMenu->AppendCheckItem(IDM_LISTJAP, _T("Show JAP"));
|
|
|
|
regionMenu->Check(IDM_LISTJAP, SConfig::GetInstance().m_ListJap);
|
|
|
|
regionMenu->AppendCheckItem(IDM_LISTPAL, _T("Show PAL"));
|
|
|
|
regionMenu->Check(IDM_LISTPAL, SConfig::GetInstance().m_ListPal);
|
|
|
|
regionMenu->AppendCheckItem(IDM_LISTUSA, _T("Show USA"));
|
|
|
|
regionMenu->Check(IDM_LISTUSA, SConfig::GetInstance().m_ListUsa);
|
|
|
|
|
2009-04-28 02:30:50 +00:00
|
|
|
viewMenu->AppendCheckItem(IDM_LISTDRIVES, _T("Show Drives"));
|
|
|
|
viewMenu->Check(IDM_LISTDRIVES, SConfig::GetInstance().m_ListDrives);
|
2009-06-06 07:36:22 +00:00
|
|
|
viewMenu->AppendSeparator();
|
2009-06-07 02:27:36 +00:00
|
|
|
viewMenu->Append(IDM_PURGECACHE, _T("Purge Cache"));
|
2009-09-03 05:24:30 +00:00
|
|
|
m_MenuBar->Append(viewMenu, _T("&View"));
|
2009-04-28 02:30:50 +00:00
|
|
|
|
2009-09-07 12:40:43 +00:00
|
|
|
if (g_pCodeWindow) g_pCodeWindow->CreateMenu(SConfig::GetInstance().m_LocalCoreStartupParameter, m_MenuBar);
|
2009-09-03 06:54:46 +00:00
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
// 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..."));
|
2009-09-03 05:24:30 +00:00
|
|
|
m_MenuBar->Append(helpMenu, _T("&Help"));
|
2009-02-23 06:15:48 +00:00
|
|
|
|
|
|
|
// Associate the menu bar with the frame
|
2009-09-03 05:24:30 +00:00
|
|
|
SetMenuBar(m_MenuBar);
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-09-02 21:00:45 +00:00
|
|
|
|
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
// Create toolbar items
|
2009-09-08 16:07:13 +00:00
|
|
|
// ---------------------
|
2009-08-27 07:33:07 +00:00
|
|
|
void CFrame::PopulateToolbar(wxAuiToolBar* ToolBar)
|
2009-02-23 06:15:48 +00:00
|
|
|
{
|
|
|
|
int w = m_Bitmaps[Toolbar_FileOpen].GetWidth(),
|
|
|
|
h = m_Bitmaps[Toolbar_FileOpen].GetHeight();
|
2009-09-08 08:47:33 +00:00
|
|
|
ToolBar->SetToolBitmapSize(wxSize(w, h));
|
|
|
|
|
2009-09-02 15:38:04 +00:00
|
|
|
|
2009-08-27 07:33:07 +00:00
|
|
|
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();
|
2009-09-08 08:47:33 +00:00
|
|
|
ToolBar->AddTool(IDM_PLAY, wxT("Play"), m_Bitmaps[Toolbar_Play], _T("Play"));
|
2009-08-27 07:33:07 +00:00
|
|
|
ToolBar->AddTool(IDM_STOP, _T("Stop"), m_Bitmaps[Toolbar_Stop], _T("Stop"));
|
|
|
|
ToolBar->AddTool(IDM_TOGGLE_FULLSCREEN, _T("Fullscr."), m_Bitmaps[Toolbar_FullScreen], _T("Toggle Fullscreen"));
|
|
|
|
ToolBar->AddTool(IDM_SCREENSHOT, _T("Scr.Shot"), m_Bitmaps[Toolbar_FullScreen], _T("Take Screenshot"));
|
|
|
|
ToolBar->AddSeparator();
|
|
|
|
ToolBar->AddTool(IDM_CONFIG_MAIN, _T("Config"), m_Bitmaps[Toolbar_PluginOptions], _T("Configure..."));
|
2009-09-08 08:47:33 +00:00
|
|
|
ToolBar->AddTool(IDM_CONFIG_GFX_PLUGIN, _T("Graphics"), m_Bitmaps[Toolbar_PluginGFX], _T("Graphics settings"));
|
2009-08-27 07:33:07 +00:00
|
|
|
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->AddTool(IDM_CONFIG_WIIMOTE_PLUGIN, _T("Wiimote"), m_Bitmaps[Toolbar_Wiimote], _T("Wiimote settings"));
|
2009-09-15 21:35:32 +00:00
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
// after adding the buttons to the toolbar, must call Realize() to reflect
|
|
|
|
// the changes
|
2009-08-27 07:33:07 +00:00
|
|
|
ToolBar->Realize();
|
|
|
|
}
|
2009-12-28 19:34:19 +00:00
|
|
|
|
2009-08-27 07:33:07 +00:00
|
|
|
void CFrame::PopulateToolbarAui(wxAuiToolBar* ToolBar)
|
|
|
|
{
|
|
|
|
int w = m_Bitmaps[Toolbar_FileOpen].GetWidth(),
|
|
|
|
h = m_Bitmaps[Toolbar_FileOpen].GetHeight();
|
|
|
|
ToolBar->SetToolBitmapSize(wxSize(w, h));
|
|
|
|
|
2009-08-30 19:44:42 +00:00
|
|
|
ToolBar->AddTool(IDM_SAVE_PERSPECTIVE, wxT("Save"), g_pCodeWindow->m_Bitmaps[Toolbar_GotoPC], wxT("Save current perspective"));
|
2009-09-01 19:47:04 +00:00
|
|
|
ToolBar->AddTool(IDM_EDIT_PERSPECTIVES, wxT("Edit"), g_pCodeWindow->m_Bitmaps[Toolbar_GotoPC], wxT("Edit current perspective"));
|
2009-08-30 19:44:42 +00:00
|
|
|
|
|
|
|
ToolBar->SetToolDropDown(IDM_SAVE_PERSPECTIVE, true);
|
2009-09-01 19:47:04 +00:00
|
|
|
ToolBar->SetToolDropDown(IDM_EDIT_PERSPECTIVES, true);
|
2009-08-27 07:33:07 +00:00
|
|
|
|
|
|
|
ToolBar->Realize();
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Delete and recreate the toolbar
|
|
|
|
void CFrame::RecreateToolbar()
|
|
|
|
{
|
2009-09-15 21:35:32 +00:00
|
|
|
if (m_ToolBar)
|
|
|
|
{
|
|
|
|
m_Mgr->DetachPane(m_ToolBar);
|
|
|
|
m_ToolBar->Destroy();
|
|
|
|
}
|
|
|
|
|
2009-09-01 19:47:04 +00:00
|
|
|
m_ToolBar = new wxAuiToolBar(this, ID_TOOLBAR, wxDefaultPosition, wxDefaultSize, TOOLBAR_STYLE);
|
2009-12-28 19:34:19 +00:00
|
|
|
|
2009-08-25 07:49:23 +00:00
|
|
|
PopulateToolbar(m_ToolBar);
|
2009-09-01 12:44:02 +00:00
|
|
|
|
2009-08-25 07:49:23 +00:00
|
|
|
m_Mgr->AddPane(m_ToolBar, wxAuiPaneInfo().
|
2009-08-25 06:34:58 +00:00
|
|
|
Name(wxT("TBMain")).Caption(wxT("TBMain")).
|
2009-08-25 01:50:27 +00:00
|
|
|
ToolbarPane().Top().
|
2009-08-25 07:49:23 +00:00
|
|
|
LeftDockable(false).RightDockable(false).Floatable(false));
|
2009-08-25 01:50:27 +00:00
|
|
|
|
2009-09-15 21:35:32 +00:00
|
|
|
if (g_pCodeWindow && !m_ToolBarDebug)
|
2009-08-25 01:50:27 +00:00
|
|
|
{
|
2009-09-01 19:47:04 +00:00
|
|
|
m_ToolBarDebug = new wxAuiToolBar(this, ID_TOOLBAR_DEBUG, wxDefaultPosition, wxDefaultSize, TOOLBAR_STYLE);
|
2009-08-27 07:33:07 +00:00
|
|
|
g_pCodeWindow->PopulateToolbar(m_ToolBarDebug);
|
2009-09-01 12:44:02 +00:00
|
|
|
|
2009-08-27 07:33:07 +00:00
|
|
|
m_Mgr->AddPane(m_ToolBarDebug, wxAuiPaneInfo().
|
2009-08-25 06:34:58 +00:00
|
|
|
Name(wxT("TBDebug")).Caption(wxT("TBDebug")).
|
2009-08-25 01:50:27 +00:00
|
|
|
ToolbarPane().Top().
|
2009-08-25 07:49:23 +00:00
|
|
|
LeftDockable(false).RightDockable(false).Floatable(false));
|
2009-08-27 07:33:07 +00:00
|
|
|
|
2009-09-01 19:47:04 +00:00
|
|
|
m_ToolBarAui = new wxAuiToolBar(this, ID_TOOLBAR_AUI, wxDefaultPosition, wxDefaultSize, TOOLBAR_STYLE);
|
2009-08-27 07:33:07 +00:00
|
|
|
PopulateToolbarAui(m_ToolBarAui);
|
|
|
|
m_Mgr->AddPane(m_ToolBarAui, wxAuiPaneInfo().
|
|
|
|
Name(wxT("TBAui")).Caption(wxT("TBAui")).
|
|
|
|
ToolbarPane().Top().
|
|
|
|
LeftDockable(false).RightDockable(false).Floatable(false));
|
2009-08-25 01:50:27 +00:00
|
|
|
}
|
2009-09-15 21:35:32 +00:00
|
|
|
|
|
|
|
UpdateGUI();
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
2009-06-18 08:22:02 +00:00
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
void CFrame::InitBitmaps()
|
|
|
|
{
|
|
|
|
// Get selected theme
|
|
|
|
int Theme = SConfig::GetInstance().m_LocalCoreStartupParameter.iTheme;
|
|
|
|
|
2009-06-18 08:22:02 +00:00
|
|
|
// Save memory by only having one set of bitmaps loaded at any time. I mean, they are still
|
2009-12-28 19:34:19 +00:00
|
|
|
// in the exe, which is in memory, but at least we wont make another copy of all of them.
|
2009-02-23 06:15:48 +00:00
|
|
|
switch (Theme)
|
|
|
|
{
|
|
|
|
case BOOMY:
|
|
|
|
{
|
|
|
|
// These are stored as 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_Stop] = wxGetBitmapFromMemory(toolbar_stop_png);
|
|
|
|
m_Bitmaps[Toolbar_Pause] = wxGetBitmapFromMemory(toolbar_pause_png);
|
|
|
|
m_Bitmaps[Toolbar_PluginOptions]= wxGetBitmapFromMemory(toolbar_plugin_options_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);
|
2009-02-27 06:24:54 +00:00
|
|
|
m_Bitmaps[Toolbar_Wiimote] = wxGetBitmapFromMemory(toolbar_plugin_pad_png);
|
|
|
|
m_Bitmaps[Toolbar_Screenshot] = wxGetBitmapFromMemory(toolbar_fullscreen_png);
|
2009-02-23 06:15:48 +00:00
|
|
|
m_Bitmaps[Toolbar_FullScreen] = wxGetBitmapFromMemory(toolbar_fullscreen_png);
|
|
|
|
m_Bitmaps[Toolbar_Help] = wxGetBitmapFromMemory(toolbar_help_png);
|
|
|
|
|
|
|
|
// Scale the 48x48 bitmaps to 24x24
|
|
|
|
for (size_t n = Toolbar_FileOpen; n <= Toolbar_Help; n++)
|
|
|
|
{
|
|
|
|
m_Bitmaps[n] = wxBitmap(m_Bitmaps[n].ConvertToImage().Scale(24, 24));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VISTA:
|
|
|
|
{
|
|
|
|
// These are stored as 24x24 and need no scaling
|
|
|
|
m_Bitmaps[Toolbar_FileOpen] = wxGetBitmapFromMemory(Toolbar_Open1_png);
|
|
|
|
m_Bitmaps[Toolbar_Refresh] = wxGetBitmapFromMemory(Toolbar_Refresh1_png);
|
|
|
|
m_Bitmaps[Toolbar_Browse] = wxGetBitmapFromMemory(Toolbar_Browse1_png);
|
|
|
|
m_Bitmaps[Toolbar_Play] = wxGetBitmapFromMemory(Toolbar_Play1_png);
|
|
|
|
m_Bitmaps[Toolbar_Stop] = wxGetBitmapFromMemory(Toolbar_Stop1_png);
|
|
|
|
m_Bitmaps[Toolbar_Pause] = wxGetBitmapFromMemory(Toolbar_Pause1_png);
|
|
|
|
m_Bitmaps[Toolbar_PluginOptions]= wxGetBitmapFromMemory(Toolbar_Options1_png);
|
|
|
|
m_Bitmaps[Toolbar_PluginGFX] = wxGetBitmapFromMemory(Toolbar_Gfx1_png);
|
|
|
|
m_Bitmaps[Toolbar_PluginDSP] = wxGetBitmapFromMemory(Toolbar_DSP1_png);
|
|
|
|
m_Bitmaps[Toolbar_PluginPAD] = wxGetBitmapFromMemory(Toolbar_Pad1_png);
|
|
|
|
m_Bitmaps[Toolbar_Wiimote] = wxGetBitmapFromMemory(Toolbar_Wiimote1_png);
|
2009-02-27 06:24:54 +00:00
|
|
|
m_Bitmaps[Toolbar_Screenshot] = wxGetBitmapFromMemory(Toolbar_Fullscreen1_png);
|
2009-02-23 06:15:48 +00:00
|
|
|
m_Bitmaps[Toolbar_FullScreen] = wxGetBitmapFromMemory(Toolbar_Fullscreen1_png);
|
|
|
|
m_Bitmaps[Toolbar_Help] = wxGetBitmapFromMemory(Toolbar_Help1_png);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case XPLASTIK:
|
|
|
|
{
|
|
|
|
m_Bitmaps[Toolbar_FileOpen] = wxGetBitmapFromMemory(Toolbar_Open2_png);
|
|
|
|
m_Bitmaps[Toolbar_Refresh] = wxGetBitmapFromMemory(Toolbar_Refresh2_png);
|
|
|
|
m_Bitmaps[Toolbar_Browse] = wxGetBitmapFromMemory(Toolbar_Browse2_png);
|
|
|
|
m_Bitmaps[Toolbar_Play] = wxGetBitmapFromMemory(Toolbar_Play2_png);
|
|
|
|
m_Bitmaps[Toolbar_Stop] = wxGetBitmapFromMemory(Toolbar_Stop2_png);
|
|
|
|
m_Bitmaps[Toolbar_Pause] = wxGetBitmapFromMemory(Toolbar_Pause2_png);
|
|
|
|
m_Bitmaps[Toolbar_PluginOptions]= wxGetBitmapFromMemory(Toolbar_Options2_png);
|
|
|
|
m_Bitmaps[Toolbar_PluginGFX] = wxGetBitmapFromMemory(Toolbar_Gfx2_png);
|
|
|
|
m_Bitmaps[Toolbar_PluginDSP] = wxGetBitmapFromMemory(Toolbar_DSP2_png);
|
|
|
|
m_Bitmaps[Toolbar_PluginPAD] = wxGetBitmapFromMemory(Toolbar_Pad2_png);
|
|
|
|
m_Bitmaps[Toolbar_Wiimote] = wxGetBitmapFromMemory(Toolbar_Wiimote2_png);
|
2009-02-27 06:24:54 +00:00
|
|
|
m_Bitmaps[Toolbar_Screenshot] = wxGetBitmapFromMemory(Toolbar_Fullscreen2_png);
|
2009-02-23 06:15:48 +00:00
|
|
|
m_Bitmaps[Toolbar_FullScreen] = wxGetBitmapFromMemory(Toolbar_Fullscreen2_png);
|
|
|
|
m_Bitmaps[Toolbar_Help] = wxGetBitmapFromMemory(Toolbar_Help2_png);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case KDE:
|
|
|
|
{
|
|
|
|
m_Bitmaps[Toolbar_FileOpen] = wxGetBitmapFromMemory(Toolbar_Open3_png);
|
|
|
|
m_Bitmaps[Toolbar_Refresh] = wxGetBitmapFromMemory(Toolbar_Refresh3_png);
|
|
|
|
m_Bitmaps[Toolbar_Browse] = wxGetBitmapFromMemory(Toolbar_Browse3_png);
|
|
|
|
m_Bitmaps[Toolbar_Play] = wxGetBitmapFromMemory(Toolbar_Play3_png);
|
|
|
|
m_Bitmaps[Toolbar_Stop] = wxGetBitmapFromMemory(Toolbar_Stop3_png);
|
|
|
|
m_Bitmaps[Toolbar_Pause] = wxGetBitmapFromMemory(Toolbar_Pause3_png);
|
|
|
|
m_Bitmaps[Toolbar_PluginOptions]= wxGetBitmapFromMemory(Toolbar_Options3_png);
|
|
|
|
m_Bitmaps[Toolbar_PluginGFX] = wxGetBitmapFromMemory(Toolbar_Gfx3_png);
|
|
|
|
m_Bitmaps[Toolbar_PluginDSP] = wxGetBitmapFromMemory(Toolbar_DSP3_png);
|
|
|
|
m_Bitmaps[Toolbar_PluginPAD] = wxGetBitmapFromMemory(Toolbar_Pad3_png);
|
|
|
|
m_Bitmaps[Toolbar_Wiimote] = wxGetBitmapFromMemory(Toolbar_Wiimote3_png);
|
2009-02-27 06:24:54 +00:00
|
|
|
m_Bitmaps[Toolbar_Screenshot] = wxGetBitmapFromMemory(Toolbar_Fullscreen3_png);
|
2009-02-23 06:15:48 +00:00
|
|
|
m_Bitmaps[Toolbar_FullScreen] = wxGetBitmapFromMemory(Toolbar_Fullscreen3_png);
|
|
|
|
m_Bitmaps[Toolbar_Help] = wxGetBitmapFromMemory(Toolbar_Help3_png);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default: PanicAlert("Theme selection went wrong");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Update in case the bitmap has been updated
|
2009-09-15 21:35:32 +00:00
|
|
|
if (m_ToolBar != NULL) RecreateToolbar();
|
2009-08-27 10:10:07 +00:00
|
|
|
|
|
|
|
aNormalFile = wxArtProvider::GetBitmap(wxART_NORMAL_FILE, wxART_OTHER, wxSize(16,16));
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-09-02 21:00:45 +00:00
|
|
|
|
|
|
|
|
2009-08-25 07:49:23 +00:00
|
|
|
// Menu items
|
2009-09-08 16:07:13 +00:00
|
|
|
// ---------------------
|
2009-08-25 07:49:23 +00:00
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
// Start the game or change the disc
|
|
|
|
void CFrame::BootGame()
|
|
|
|
{
|
|
|
|
if (Core::GetState() != Core::CORE_UNINITIALIZED)
|
2009-12-28 19:34:19 +00:00
|
|
|
return;
|
|
|
|
|
2009-09-15 05:38:49 +00:00
|
|
|
// Start the selected ISO, or try one of the saved paths.
|
|
|
|
// If all that fails, ask to add a dir and don't boot
|
|
|
|
else if (m_GameListCtrl->GetSelectedISO() != NULL)
|
2009-02-23 06:15:48 +00:00
|
|
|
{
|
2009-09-15 05:38:49 +00:00
|
|
|
if (m_GameListCtrl->GetSelectedISO()->IsValid())
|
|
|
|
BootManager::BootCore(m_GameListCtrl->GetSelectedISO()->GetFileName());
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
2009-09-15 05:38:49 +00:00
|
|
|
else
|
2009-02-23 06:15:48 +00:00
|
|
|
{
|
2009-09-15 05:38:49 +00:00
|
|
|
SCoreStartupParameter& StartUp = SConfig::GetInstance().m_LocalCoreStartupParameter;
|
|
|
|
|
|
|
|
if (!StartUp.m_strDefaultGCM.empty()
|
|
|
|
&& wxFileExists(wxString(StartUp.m_strDefaultGCM.c_str(), wxConvUTF8)))
|
|
|
|
{
|
|
|
|
BootManager::BootCore(StartUp.m_strDefaultGCM);
|
|
|
|
}
|
|
|
|
else if (!SConfig::GetInstance().m_LastFilename.empty()
|
|
|
|
&& wxFileExists(wxString(SConfig::GetInstance().m_LastFilename.c_str(), wxConvUTF8)))
|
|
|
|
{
|
|
|
|
BootManager::BootCore(SConfig::GetInstance().m_LastFilename);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_GameListCtrl->BrowseForDirectory();
|
|
|
|
return;
|
|
|
|
}
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-18 08:22:02 +00:00
|
|
|
// Open file to boot
|
2009-02-23 06:15:48 +00:00
|
|
|
void CFrame::OnOpen(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
|
|
|
DoOpen(true);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CFrame::DoOpen(bool Boot)
|
|
|
|
{
|
2009-07-30 07:09:26 +00:00
|
|
|
std::string currentDir = File::GetCurrentDir();
|
2009-02-24 07:18:08 +00:00
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
wxString path = wxFileSelector(
|
|
|
|
_T("Select the file to load"),
|
|
|
|
wxEmptyString, wxEmptyString, wxEmptyString,
|
|
|
|
wxString::Format
|
|
|
|
(
|
|
|
|
_T("All GC/Wii files (elf, dol, gcm, iso, wad)|*.elf;*.dol;*.gcm;*.iso;*.gcz;*.wad|All files (%s)|%s"),
|
|
|
|
wxFileSelectorDefaultWildcardStr,
|
|
|
|
wxFileSelectorDefaultWildcardStr
|
|
|
|
),
|
|
|
|
wxFD_OPEN | wxFD_PREVIEW | wxFD_FILE_MUST_EXIST,
|
|
|
|
this);
|
2009-06-18 08:22:02 +00:00
|
|
|
|
2009-07-01 04:55:53 +00:00
|
|
|
bool fileChosen = !path.IsEmpty();
|
2009-02-23 06:15:48 +00:00
|
|
|
|
2009-07-30 07:09:26 +00:00
|
|
|
std::string currentDir2 = File::GetCurrentDir();
|
2009-02-24 07:18:08 +00:00
|
|
|
|
|
|
|
if (currentDir != currentDir2)
|
|
|
|
{
|
2009-06-18 08:22:02 +00:00
|
|
|
PanicAlert("Current dir changed from %s to %s after wxFileSelector!",currentDir.c_str(),currentDir2.c_str());
|
2009-07-30 07:09:26 +00:00
|
|
|
File::SetCurrentDir(currentDir.c_str());
|
2009-02-24 07:18:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
// Should we boot a new game or just change the disc?
|
2009-06-18 08:22:02 +00:00
|
|
|
if (Boot)
|
2009-02-23 06:15:48 +00:00
|
|
|
{
|
2009-06-18 08:22:02 +00:00
|
|
|
if (!fileChosen)
|
|
|
|
return;
|
2009-08-02 05:59:55 +00:00
|
|
|
BootManager::BootCore(std::string(path.mb_str()));
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2009-06-18 08:22:02 +00:00
|
|
|
if (!fileChosen)
|
|
|
|
path = wxT("");
|
2009-08-12 05:57:59 +00:00
|
|
|
// temp is deleted by changediscCallback
|
|
|
|
char * temp = new char[strlen(path.mb_str())];
|
|
|
|
strncpy(temp, path.mb_str(), strlen(path.mb_str()));
|
|
|
|
DVDInterface::ChangeDisc(temp);
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-08-22 02:05:02 +00:00
|
|
|
void CFrame::OnFrameStep(wxCommandEvent& event)
|
|
|
|
{
|
|
|
|
Frame::SetFrameStepping(event.IsChecked());
|
|
|
|
}
|
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
void CFrame::OnChangeDisc(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
|
|
|
DoOpen(false);
|
|
|
|
}
|
|
|
|
|
2009-08-21 09:26:34 +00:00
|
|
|
void CFrame::OnRecord(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
|
|
|
wxString path = wxFileSelector(
|
|
|
|
_T("Select The Recording File"),
|
|
|
|
wxEmptyString, wxEmptyString, wxEmptyString,
|
|
|
|
wxString::Format
|
|
|
|
(
|
|
|
|
_T("Dolphin TAS Movies (*.dtm)|*.dtm|All files (%s)|%s"),
|
|
|
|
wxFileSelectorDefaultWildcardStr,
|
|
|
|
wxFileSelectorDefaultWildcardStr
|
|
|
|
),
|
|
|
|
wxFD_SAVE | wxFD_PREVIEW | wxFD_FILE_MUST_EXIST,
|
|
|
|
this);
|
|
|
|
|
|
|
|
if(path.IsEmpty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
// TODO: Take controller settings from Gamecube Configuration menu
|
2009-08-21 19:55:03 +00:00
|
|
|
if(Frame::BeginRecordingInput(path.mb_str(), 1))
|
|
|
|
BootGame();
|
|
|
|
}
|
|
|
|
|
|
|
|
void CFrame::OnPlayRecording(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
|
|
|
wxString path = wxFileSelector(
|
|
|
|
_T("Select The Recording File"),
|
|
|
|
wxEmptyString, wxEmptyString, wxEmptyString,
|
|
|
|
wxString::Format
|
|
|
|
(
|
|
|
|
_T("Dolphin TAS Movies (*.dtm)|*.dtm|All files (%s)|%s"),
|
|
|
|
wxFileSelectorDefaultWildcardStr,
|
|
|
|
wxFileSelectorDefaultWildcardStr
|
|
|
|
),
|
|
|
|
wxFD_OPEN | wxFD_PREVIEW | wxFD_FILE_MUST_EXIST,
|
|
|
|
this);
|
|
|
|
|
|
|
|
if(path.IsEmpty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
if(Frame::PlayInput(path.mb_str()))
|
|
|
|
BootGame();
|
2009-08-21 09:26:34 +00:00
|
|
|
}
|
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
void CFrame::OnPlay(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
2009-12-28 19:34:19 +00:00
|
|
|
if (Core::GetState() != Core::CORE_UNINITIALIZED)
|
|
|
|
{
|
|
|
|
if (UseDebugger)
|
|
|
|
{
|
|
|
|
if (CCPU::IsStepping())
|
|
|
|
CCPU::EnableStepping(false);
|
|
|
|
else
|
|
|
|
CCPU::EnableStepping(true); // Break
|
|
|
|
|
|
|
|
wxThread::Sleep(20);
|
|
|
|
g_pCodeWindow->JumpToAddress(PC);
|
|
|
|
g_pCodeWindow->Update();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (Core::GetState() == Core::CORE_RUN)
|
|
|
|
Core::SetState(Core::CORE_PAUSE);
|
|
|
|
else
|
|
|
|
Core::SetState(Core::CORE_RUN);
|
|
|
|
}
|
|
|
|
|
|
|
|
UpdateGUI();
|
|
|
|
}
|
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
BootGame();
|
|
|
|
}
|
|
|
|
|
|
|
|
void CFrame::OnBootDrive(wxCommandEvent& event)
|
|
|
|
{
|
2009-02-24 15:04:12 +00:00
|
|
|
BootManager::BootCore(drives[event.GetId()-IDM_DRIVE1]);
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
2009-06-20 11:05:52 +00:00
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
|
|
|
|
// Refresh the file list and browse for a favorites directory
|
|
|
|
void CFrame::OnRefresh(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
2009-09-06 13:36:05 +00:00
|
|
|
if (m_GameListCtrl) m_GameListCtrl->Update();
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void CFrame::OnBrowse(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
2009-09-06 13:36:05 +00:00
|
|
|
if (m_GameListCtrl) m_GameListCtrl->BrowseForDirectory();
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
2009-02-27 03:56:34 +00:00
|
|
|
|
2009-06-20 11:05:52 +00:00
|
|
|
// Create screenshot
|
2009-02-27 03:56:34 +00:00
|
|
|
void CFrame::OnScreenshot(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
2009-06-28 19:47:02 +00:00
|
|
|
Core::ScreenShot();
|
2009-02-27 03:56:34 +00:00
|
|
|
}
|
2009-02-23 06:15:48 +00:00
|
|
|
|
|
|
|
// Stop the emulation
|
|
|
|
void CFrame::DoStop()
|
|
|
|
{
|
|
|
|
if (Core::GetState() != Core::CORE_UNINITIALIZED)
|
|
|
|
{
|
2009-04-28 23:47:18 +00:00
|
|
|
// Ask for confirmation in case the user accidently clicked Stop / Escape
|
|
|
|
if(SConfig::GetInstance().m_LocalCoreStartupParameter.bConfirmStop)
|
2009-09-03 09:13:41 +00:00
|
|
|
if(!AskYesNo("Do want to stop the current emulation?", "Confirm", wxYES_NO))
|
2009-04-28 23:47:18 +00:00
|
|
|
return;
|
2009-08-21 09:26:34 +00:00
|
|
|
|
|
|
|
// TODO: Show the author/description dialog here
|
|
|
|
if(Frame::IsRecordingInput())
|
|
|
|
Frame::EndRecordingInput();
|
2009-08-21 20:15:33 +00:00
|
|
|
if(Frame::IsPlayingInput())
|
|
|
|
Frame::EndPlayInput();
|
2009-04-28 23:47:18 +00:00
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
Core::Stop();
|
|
|
|
UpdateGUI();
|
2010-01-01 03:55:39 +00:00
|
|
|
|
|
|
|
// Clean framerate indications from the status bar.
|
|
|
|
m_pStatusBar->SetStatusText(wxT(" "), 0);
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void CFrame::OnStop(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
2009-04-28 23:47:18 +00:00
|
|
|
DoStop();
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
2009-06-20 11:05:52 +00:00
|
|
|
|
2009-10-06 15:49:20 +00:00
|
|
|
void CFrame::OnReset(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
|
|
|
ProcessorInterface::ResetButton_Tap();
|
|
|
|
}
|
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
void CFrame::OnConfigMain(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
2009-11-01 01:24:30 +00:00
|
|
|
m_bModalDialogOpen = true;
|
2009-02-23 06:15:48 +00:00
|
|
|
CConfigMain ConfigMain(this);
|
|
|
|
if (ConfigMain.ShowModal() == wxID_OK)
|
|
|
|
m_GameListCtrl->Update();
|
2009-11-01 01:24:30 +00:00
|
|
|
m_bModalDialogOpen = false;
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void CFrame::OnPluginGFX(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
|
|
|
CPluginManager::GetInstance().OpenConfig(
|
|
|
|
GetHandle(),
|
|
|
|
SConfig::GetInstance().m_LocalCoreStartupParameter.m_strVideoPlugin.c_str(),
|
|
|
|
PLUGIN_TYPE_VIDEO
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void CFrame::OnPluginDSP(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
|
|
|
CPluginManager::GetInstance().OpenConfig(
|
|
|
|
GetHandle(),
|
|
|
|
SConfig::GetInstance().m_LocalCoreStartupParameter.m_strDSPPlugin.c_str(),
|
|
|
|
PLUGIN_TYPE_DSP
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CFrame::OnPluginPAD(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
|
|
|
CPluginManager::GetInstance().OpenConfig(
|
|
|
|
m_Panel->GetHandle(),
|
|
|
|
SConfig::GetInstance().m_LocalCoreStartupParameter.m_strPadPlugin[0].c_str(),
|
|
|
|
PLUGIN_TYPE_PAD
|
|
|
|
);
|
|
|
|
}
|
|
|
|
void CFrame::OnPluginWiimote(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
|
|
|
CPluginManager::GetInstance().OpenConfig(
|
|
|
|
GetHandle(),
|
|
|
|
SConfig::GetInstance().m_LocalCoreStartupParameter.m_strWiimotePlugin[0].c_str(),
|
|
|
|
PLUGIN_TYPE_WIIMOTE
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
void CFrame::OnHelp(wxCommandEvent& event)
|
|
|
|
{
|
|
|
|
switch (event.GetId())
|
|
|
|
{
|
|
|
|
case IDM_HELPABOUT:
|
|
|
|
{
|
2009-11-01 01:24:30 +00:00
|
|
|
m_bModalDialogOpen = true;
|
|
|
|
AboutDolphin frame(this);
|
|
|
|
frame.ShowModal();
|
|
|
|
m_bModalDialogOpen = false;
|
2009-02-23 06:15:48 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case IDM_HELPWEBSITE:
|
2009-02-24 19:31:32 +00:00
|
|
|
WxUtils::Launch("http://www.dolphin-emu.com/");
|
2009-02-23 06:15:48 +00:00
|
|
|
break;
|
|
|
|
case IDM_HELPGOOGLECODE:
|
2009-02-24 19:31:32 +00:00
|
|
|
WxUtils::Launch("http://code.google.com/p/dolphin-emu/");
|
2009-02-23 06:15:48 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2009-08-27 07:33:07 +00:00
|
|
|
|
2009-09-01 19:47:04 +00:00
|
|
|
void CFrame::ClearStatusBar()
|
2009-08-27 07:33:07 +00:00
|
|
|
{
|
2009-09-01 19:47:04 +00:00
|
|
|
if (this->GetStatusBar()->IsEnabled()) this->GetStatusBar()->SetStatusText(wxT(""),0);
|
2009-08-27 07:33:07 +00:00
|
|
|
}
|
2009-09-08 21:16:05 +00:00
|
|
|
|
|
|
|
void CFrame::StatusBarMessage(const char * Text, ...)
|
2009-09-03 07:59:24 +00:00
|
|
|
{
|
|
|
|
const int MAX_BYTES = 1024*10;
|
|
|
|
char Str[MAX_BYTES];
|
|
|
|
va_list ArgPtr;
|
|
|
|
int Cnt;
|
|
|
|
va_start(ArgPtr, Text);
|
|
|
|
Cnt = vsnprintf(Str, MAX_BYTES, Text, ArgPtr);
|
|
|
|
va_end(ArgPtr);
|
|
|
|
|
|
|
|
if (this->GetStatusBar()->IsEnabled()) this->GetStatusBar()->SetStatusText(wxString::FromAscii(Str),0);
|
|
|
|
}
|
2009-02-23 06:15:48 +00:00
|
|
|
|
2009-09-02 21:00:45 +00:00
|
|
|
|
2009-08-29 06:08:14 +00:00
|
|
|
// Miscellaneous menus
|
2009-09-08 16:07:13 +00:00
|
|
|
// ---------------------
|
2009-05-13 21:50:24 +00:00
|
|
|
// NetPlay stuff
|
|
|
|
void CFrame::OnNetPlay(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
2009-05-13 22:23:54 +00:00
|
|
|
#if defined(HAVE_SFML) && HAVE_SFML
|
2009-05-13 21:50:24 +00:00
|
|
|
new NetPlay(this, m_GameListCtrl->GetGamePaths(), m_GameListCtrl->GetGameNames());
|
2009-05-13 22:23:54 +00:00
|
|
|
#endif
|
2009-05-13 21:50:24 +00:00
|
|
|
}
|
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
void CFrame::OnMemcard(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
2009-11-01 01:24:30 +00:00
|
|
|
m_bModalDialogOpen = true;
|
2009-02-23 06:15:48 +00:00
|
|
|
CMemcardManager MemcardManager(this);
|
|
|
|
MemcardManager.ShowModal();
|
2009-11-01 01:24:30 +00:00
|
|
|
m_bModalDialogOpen = false;
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
|
|
|
|
2009-11-07 23:54:10 +00:00
|
|
|
void CFrame::OnOpenLuaWindow(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
|
|
|
new wxLuaWindow(this, wxDefaultPosition, wxSize(600, 390));
|
|
|
|
}
|
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
void CFrame::OnShow_CheatsWindow(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
|
|
|
CheatsWindow = new wxCheatsWindow(this, wxDefaultPosition, wxSize(600, 390));
|
|
|
|
}
|
2009-03-20 19:12:04 +00:00
|
|
|
|
2009-02-27 23:44:15 +00:00
|
|
|
void CFrame::OnLoadWiiMenu(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
2009-08-12 05:57:59 +00:00
|
|
|
BootManager::BootCore(FULL_WII_MENU_DIR);
|
2009-02-27 23:44:15 +00:00
|
|
|
}
|
|
|
|
|
2009-12-27 19:31:02 +00:00
|
|
|
void CFrame::OnConnectWiimote(wxCommandEvent& event)
|
|
|
|
{
|
2009-12-30 09:00:43 +00:00
|
|
|
if (Core::isRunning() && Core::GetStartupParameter().bWii)
|
|
|
|
{
|
|
|
|
int Id = event.GetId() - IDM_CONNECT_WIIMOTE1;
|
|
|
|
GetUsbPointer()->AccessWiiMote(Id | 0x100)->Activate(event.IsChecked());
|
|
|
|
}
|
2009-12-27 19:31:02 +00:00
|
|
|
}
|
|
|
|
|
2009-06-18 08:22:02 +00:00
|
|
|
// Toogle fullscreen. In Windows the fullscreen mode is accomplished by expanding the m_Panel to cover
|
|
|
|
// the entire screen (when we render to the main window).
|
2009-02-23 06:15:48 +00:00
|
|
|
void CFrame::OnToggleFullscreen(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
2009-10-24 21:31:28 +00:00
|
|
|
DoFullscreen(!IsFullScreen());
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void CFrame::OnToggleDualCore(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
2009-10-23 15:26:35 +00:00
|
|
|
SConfig::GetInstance().m_LocalCoreStartupParameter.bCPUThread = !SConfig::GetInstance().m_LocalCoreStartupParameter.bCPUThread;
|
2009-02-23 06:15:48 +00:00
|
|
|
SConfig::GetInstance().SaveSettings();
|
|
|
|
}
|
2009-03-20 19:12:04 +00:00
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
void CFrame::OnToggleSkipIdle(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
|
|
|
SConfig::GetInstance().m_LocalCoreStartupParameter.bSkipIdle = !SConfig::GetInstance().m_LocalCoreStartupParameter.bSkipIdle;
|
|
|
|
SConfig::GetInstance().SaveSettings();
|
|
|
|
}
|
|
|
|
|
2009-06-28 01:11:35 +00:00
|
|
|
void CFrame::OnLoadStateFromFile(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
|
|
|
wxString path = wxFileSelector(
|
|
|
|
_T("Select the state to load"),
|
|
|
|
wxEmptyString, wxEmptyString, wxEmptyString,
|
|
|
|
wxString::Format
|
|
|
|
(
|
|
|
|
_T("All Save States (sav, s##)|*.sav;*.s??|All files (%s)|%s"),
|
|
|
|
wxFileSelectorDefaultWildcardStr,
|
|
|
|
wxFileSelectorDefaultWildcardStr
|
|
|
|
),
|
|
|
|
wxFD_OPEN | wxFD_PREVIEW | wxFD_FILE_MUST_EXIST,
|
|
|
|
this);
|
|
|
|
|
2009-10-05 07:31:38 +00:00
|
|
|
if(!path.IsEmpty())
|
2009-08-02 05:59:55 +00:00
|
|
|
State_LoadAs((const char*)path.mb_str());
|
2009-06-28 01:11:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void CFrame::OnSaveStateToFile(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
|
|
|
wxString path = wxFileSelector(
|
|
|
|
_T("Select the state to save"),
|
|
|
|
wxEmptyString, wxEmptyString, wxEmptyString,
|
|
|
|
wxString::Format
|
|
|
|
(
|
|
|
|
_T("All Save States (sav, s##)|*.sav;*.s??|All files (%s)|%s"),
|
|
|
|
wxFileSelectorDefaultWildcardStr,
|
|
|
|
wxFileSelectorDefaultWildcardStr
|
|
|
|
),
|
|
|
|
wxFD_SAVE,
|
|
|
|
this);
|
|
|
|
|
2009-10-05 07:31:38 +00:00
|
|
|
if(! path.IsEmpty())
|
2009-08-02 05:59:55 +00:00
|
|
|
State_SaveAs((const char*)path.mb_str());
|
2009-06-28 01:11:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void CFrame::OnLoadLastState(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
|
|
|
State_LoadLastSaved();
|
|
|
|
}
|
|
|
|
|
2009-06-28 21:11:51 +00:00
|
|
|
void CFrame::OnUndoLoadState(wxCommandEvent& WXUNUSED (event))
|
2009-06-28 01:11:35 +00:00
|
|
|
{
|
2009-06-28 21:11:51 +00:00
|
|
|
State_UndoLoadState();
|
2009-06-28 01:11:35 +00:00
|
|
|
}
|
|
|
|
|
2009-06-28 21:11:51 +00:00
|
|
|
void CFrame::OnUndoSaveState(wxCommandEvent& WXUNUSED (event))
|
|
|
|
{
|
|
|
|
State_UndoSaveState();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2009-08-08 01:39:56 +00:00
|
|
|
void CFrame::OnFrameSkip(wxCommandEvent& event)
|
|
|
|
{
|
|
|
|
int amount = event.GetId() - IDM_FRAMESKIP0;
|
|
|
|
|
|
|
|
Frame::SetFrameSkipping((unsigned int)amount);
|
|
|
|
}
|
|
|
|
|
2009-08-25 07:49:23 +00:00
|
|
|
|
2009-09-02 21:00:45 +00:00
|
|
|
|
|
|
|
|
2009-08-27 10:10:07 +00:00
|
|
|
// GUI
|
2009-09-08 16:07:13 +00:00
|
|
|
// ---------------------
|
2009-02-23 06:15:48 +00:00
|
|
|
|
|
|
|
// Update the enabled/disabled status
|
|
|
|
void CFrame::UpdateGUI()
|
|
|
|
{
|
2009-12-31 16:25:12 +00:00
|
|
|
if (!m_bControlsCreated)
|
|
|
|
return;
|
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
// Save status
|
2009-09-07 12:40:43 +00:00
|
|
|
bool Initialized = Core::isRunning();
|
|
|
|
bool Running = Core::GetState() == Core::CORE_RUN;
|
|
|
|
bool Paused = Core::GetState() == Core::CORE_PAUSE;
|
2009-02-23 06:15:48 +00:00
|
|
|
|
|
|
|
// Make sure that we have a toolbar
|
2009-09-15 21:35:32 +00:00
|
|
|
if (m_ToolBar)
|
2009-02-23 06:15:48 +00:00
|
|
|
{
|
|
|
|
// Enable/disable the Config and Stop buttons
|
2009-09-07 12:40:43 +00:00
|
|
|
m_ToolBar->EnableTool(wxID_OPEN, !Initialized);
|
|
|
|
m_ToolBar->EnableTool(wxID_REFRESH, !Initialized); // Don't allow refresh when we don't show the list
|
|
|
|
m_ToolBar->EnableTool(IDM_STOP, Running || Paused);
|
|
|
|
m_ToolBar->EnableTool(IDM_SCREENSHOT, Running || Paused);
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// File
|
2009-09-07 12:40:43 +00:00
|
|
|
GetMenuBar()->FindItem(wxID_OPEN)->Enable(!Initialized);
|
|
|
|
m_pSubMenuDrive->Enable(!Initialized);
|
|
|
|
GetMenuBar()->FindItem(wxID_REFRESH)->Enable(!Initialized);
|
|
|
|
GetMenuBar()->FindItem(IDM_BROWSE)->Enable(!Initialized);
|
2009-02-23 06:15:48 +00:00
|
|
|
|
|
|
|
// Emulation
|
2009-09-07 12:40:43 +00:00
|
|
|
GetMenuBar()->FindItem(IDM_STOP)->Enable(Running || Paused);
|
2009-10-22 19:13:22 +00:00
|
|
|
GetMenuBar()->FindItem(IDM_RESET)->Enable(Running || Paused);
|
2009-09-07 12:40:43 +00:00
|
|
|
GetMenuBar()->FindItem(IDM_RECORD)->Enable(!Initialized);
|
|
|
|
GetMenuBar()->FindItem(IDM_PLAYRECORD)->Enable(!Initialized);
|
|
|
|
GetMenuBar()->FindItem(IDM_FRAMESTEP)->Enable(Running || Paused);
|
|
|
|
GetMenuBar()->FindItem(IDM_SCREENSHOT)->Enable(Running || Paused);
|
2009-12-01 21:43:54 +00:00
|
|
|
|
2009-09-07 12:40:43 +00:00
|
|
|
m_pSubMenuLoad->Enable(Initialized);
|
|
|
|
m_pSubMenuSave->Enable(Initialized);
|
2009-08-08 05:47:08 +00:00
|
|
|
|
2009-02-23 06:15:48 +00:00
|
|
|
// Misc
|
2009-09-07 12:40:43 +00:00
|
|
|
GetMenuBar()->FindItem(IDM_CHANGEDISC)->Enable(Initialized);
|
2009-04-15 22:25:07 +00:00
|
|
|
if (DiscIO::CNANDContentManager::Access().GetNANDLoader(FULL_WII_MENU_DIR).IsValid())
|
2009-09-07 12:40:43 +00:00
|
|
|
GetMenuBar()->FindItem(IDM_LOAD_WII_MENU)->Enable(!Initialized);
|
2009-02-23 06:15:48 +00:00
|
|
|
|
2009-12-30 09:00:43 +00:00
|
|
|
GetMenuBar()->FindItem(IDM_CONNECT_WIIMOTE1)->Enable(Initialized && Core::GetStartupParameter().bWii);
|
|
|
|
GetMenuBar()->FindItem(IDM_CONNECT_WIIMOTE2)->Enable(Initialized && Core::GetStartupParameter().bWii);
|
|
|
|
GetMenuBar()->FindItem(IDM_CONNECT_WIIMOTE3)->Enable(Initialized && Core::GetStartupParameter().bWii);
|
|
|
|
GetMenuBar()->FindItem(IDM_CONNECT_WIIMOTE4)->Enable(Initialized && Core::GetStartupParameter().bWii);
|
2009-12-27 19:31:02 +00:00
|
|
|
if (Initialized && Core::GetStartupParameter().bWii)
|
|
|
|
{
|
2009-12-30 09:00:43 +00:00
|
|
|
GetMenuBar()->FindItem(IDM_CONNECT_WIIMOTE1)->Check(GetUsbPointer()->AccessWiiMote(0x0100)->IsConnected() == 3);
|
|
|
|
GetMenuBar()->FindItem(IDM_CONNECT_WIIMOTE2)->Check(GetUsbPointer()->AccessWiiMote(0x0101)->IsConnected() == 3);
|
|
|
|
GetMenuBar()->FindItem(IDM_CONNECT_WIIMOTE3)->Check(GetUsbPointer()->AccessWiiMote(0x0102)->IsConnected() == 3);
|
|
|
|
GetMenuBar()->FindItem(IDM_CONNECT_WIIMOTE4)->Check(GetUsbPointer()->AccessWiiMote(0x0103)->IsConnected() == 3);
|
2009-12-27 19:31:02 +00:00
|
|
|
}
|
|
|
|
|
2009-09-07 12:40:43 +00:00
|
|
|
if (Running)
|
2009-02-23 06:15:48 +00:00
|
|
|
{
|
2009-09-15 21:35:32 +00:00
|
|
|
if (m_ToolBar)
|
2009-02-23 06:15:48 +00:00
|
|
|
{
|
2009-08-25 10:58:13 +00:00
|
|
|
m_ToolBar->SetToolBitmap(IDM_PLAY, m_Bitmaps[Toolbar_Pause]);
|
|
|
|
m_ToolBar->SetToolShortHelp(IDM_PLAY, _("Pause"));
|
|
|
|
m_ToolBar->SetToolLabel(IDM_PLAY, _("Pause"));
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
2009-06-29 09:24:39 +00:00
|
|
|
GetMenuBar()->FindItem(IDM_PLAY)->SetText(_("&Pause\tF10"));
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2009-09-15 21:35:32 +00:00
|
|
|
if (m_ToolBar)
|
2009-02-23 06:15:48 +00:00
|
|
|
{
|
2009-08-25 10:58:13 +00:00
|
|
|
m_ToolBar->SetToolBitmap(IDM_PLAY, m_Bitmaps[Toolbar_Play]);
|
|
|
|
m_ToolBar->SetToolShortHelp(IDM_PLAY, _("Play"));
|
2009-08-27 00:54:44 +00:00
|
|
|
m_ToolBar->SetToolLabel(IDM_PLAY, wxT(" Play "));
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
2009-06-29 09:24:39 +00:00
|
|
|
GetMenuBar()->FindItem(IDM_PLAY)->SetText(_("&Play\tF10"));
|
2009-02-23 06:15:48 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2009-09-07 12:40:43 +00:00
|
|
|
if (!Initialized)
|
2009-02-23 06:15:48 +00:00
|
|
|
{
|
2009-09-01 12:44:02 +00:00
|
|
|
if (m_GameListCtrl)
|
2009-02-23 06:15:48 +00:00
|
|
|
{
|
2009-09-01 12:44:02 +00:00
|
|
|
if (!m_GameListCtrl->IsShown())
|
|
|
|
{
|
2009-09-07 12:40:43 +00:00
|
|
|
m_GameListCtrl->Reparent(m_Panel);
|
2009-09-01 12:44:02 +00:00
|
|
|
m_GameListCtrl->Enable();
|
|
|
|
m_GameListCtrl->Show();
|
|
|
|
sizerPanel->FitInside(m_Panel);
|
|
|
|
}
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2009-09-01 12:44:02 +00:00
|
|
|
if (m_GameListCtrl)
|
2009-02-23 06:15:48 +00:00
|
|
|
{
|
2009-09-01 12:44:02 +00:00
|
|
|
if (m_GameListCtrl->IsShown())
|
|
|
|
{
|
|
|
|
m_GameListCtrl->Disable();
|
|
|
|
m_GameListCtrl->Hide();
|
|
|
|
}
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
|
|
|
}
|
2009-08-27 00:54:44 +00:00
|
|
|
|
2009-09-25 16:29:00 +00:00
|
|
|
if (m_ToolBar) m_ToolBar->Refresh();
|
2009-09-07 12:40:43 +00:00
|
|
|
if (g_pCodeWindow) g_pCodeWindow->Update();
|
2009-09-15 21:35:32 +00:00
|
|
|
|
2009-08-27 00:54:44 +00:00
|
|
|
// Commit changes to manager
|
|
|
|
m_Mgr->Update();
|
2009-02-23 06:15:48 +00:00
|
|
|
}
|
|
|
|
|
2009-04-28 02:30:50 +00:00
|
|
|
void CFrame::GameListChanged(wxCommandEvent& event)
|
|
|
|
{
|
|
|
|
switch (event.GetId())
|
|
|
|
{
|
|
|
|
case IDM_LISTWII:
|
|
|
|
SConfig::GetInstance().m_ListWii = event.IsChecked();
|
|
|
|
break;
|
|
|
|
case IDM_LISTGC:
|
|
|
|
SConfig::GetInstance().m_ListGC = event.IsChecked();
|
|
|
|
break;
|
2009-06-07 02:27:36 +00:00
|
|
|
case IDM_LISTWAD:
|
|
|
|
SConfig::GetInstance().m_ListWad = event.IsChecked();
|
|
|
|
break;
|
2009-04-28 02:30:50 +00:00
|
|
|
case IDM_LISTJAP:
|
|
|
|
SConfig::GetInstance().m_ListJap = event.IsChecked();
|
|
|
|
break;
|
|
|
|
case IDM_LISTPAL:
|
|
|
|
SConfig::GetInstance().m_ListPal = event.IsChecked();
|
|
|
|
break;
|
|
|
|
case IDM_LISTUSA:
|
|
|
|
SConfig::GetInstance().m_ListUsa = event.IsChecked();
|
|
|
|
break;
|
|
|
|
case IDM_LISTDRIVES:
|
|
|
|
SConfig::GetInstance().m_ListDrives = event.IsChecked();
|
|
|
|
break;
|
2009-06-06 07:36:22 +00:00
|
|
|
case IDM_PURGECACHE:
|
|
|
|
CFileSearch::XStringVector Directories;
|
|
|
|
Directories.push_back(FULL_CACHE_DIR);
|
|
|
|
CFileSearch::XStringVector Extensions;
|
|
|
|
Extensions.push_back("*.cache");
|
|
|
|
|
|
|
|
CFileSearch FileSearch(Extensions, Directories);
|
|
|
|
const CFileSearch::XStringVector& rFilenames = FileSearch.GetFileNames();
|
|
|
|
|
|
|
|
for (u32 i = 0; i < rFilenames.size(); i++)
|
|
|
|
{
|
|
|
|
File::Delete(rFilenames[i].c_str());
|
|
|
|
}
|
|
|
|
break;
|
2009-04-28 02:30:50 +00:00
|
|
|
}
|
|
|
|
|
2009-09-06 13:36:05 +00:00
|
|
|
if (m_GameListCtrl) m_GameListCtrl->Update();
|
2009-04-28 02:30:50 +00:00
|
|
|
}
|
2009-09-01 19:47:04 +00:00
|
|
|
|
|
|
|
// Enable and disable the toolbar
|
|
|
|
void CFrame::OnToggleToolbar(wxCommandEvent& event)
|
|
|
|
{
|
|
|
|
SConfig::GetInstance().m_InterfaceToolbar = event.IsChecked();
|
|
|
|
DoToggleToolbar(event.IsChecked());
|
|
|
|
}
|
2009-09-02 07:59:06 +00:00
|
|
|
void CFrame::DoToggleToolbar(bool _show)
|
2009-09-01 19:47:04 +00:00
|
|
|
{
|
2009-09-02 07:59:06 +00:00
|
|
|
if (_show)
|
2009-09-01 19:47:04 +00:00
|
|
|
{
|
|
|
|
m_Mgr->GetPane(wxT("TBMain")).Show();
|
2009-09-07 12:40:43 +00:00
|
|
|
if (g_pCodeWindow) { m_Mgr->GetPane(wxT("TBDebug")).Show(); m_Mgr->GetPane(wxT("TBAui")).Show(); }
|
2009-09-01 19:47:04 +00:00
|
|
|
m_Mgr->Update();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_Mgr->GetPane(wxT("TBMain")).Hide();
|
2009-09-07 12:40:43 +00:00
|
|
|
if (g_pCodeWindow) { m_Mgr->GetPane(wxT("TBDebug")).Hide(); m_Mgr->GetPane(wxT("TBAui")).Hide(); }
|
2009-09-01 19:47:04 +00:00
|
|
|
m_Mgr->Update();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Enable and disable the status bar
|
|
|
|
void CFrame::OnToggleStatusbar(wxCommandEvent& event)
|
|
|
|
{
|
|
|
|
SConfig::GetInstance().m_InterfaceStatusbar = event.IsChecked();
|
|
|
|
if (SConfig::GetInstance().m_InterfaceStatusbar == true)
|
|
|
|
m_pStatusBar->Show();
|
|
|
|
else
|
|
|
|
m_pStatusBar->Hide();
|
|
|
|
|
|
|
|
this->SendSizeEvent();
|
|
|
|
}
|
2009-09-02 21:00:45 +00:00
|
|
|
|