// Copyright (C) 2003 Dolphin Project.

// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, version 2.0.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License 2.0 for more details.

// A copy of the GPL 2.0 should have been included with the program.
// If not, see http://www.gnu.org/licenses/

// Official SVN repository and contact information can be found at
// http://code.google.com/p/dolphin-emu/



//////////////////////////////////////////////////////////////////////////////////////////
// Windows
/* ŻŻŻŻŻŻŻŻŻŻŻŻŻŻ

CFrame is the main parent window. Inside CFrame there is an m_Panel that 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().

///////////////////////////////////////////////*/


// ----------------------------------------------------------------------------
// includes
// ----------------------------------------------------------------------------

#include "Common.h" // Common
#include "FileUtil.h"
#include "Timer.h"
#include "Setup.h"

#include "Globals.h" // Local
#include "Frame.h"
#include "ConfigMain.h"
#include "PluginManager.h"
#include "MemcardManager.h"
#include "CheatsWindow.h"
#include "AboutDolphin.h"
#include "GameListCtrl.h"
#include "BootManager.h"

#include "ConfigManager.h" // Core
#include "Core.h"
#include "HW/DVDInterface.h"
#include "State.h"
#include "VolumeHandler.h"

#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"
};


/////////////////////////////////////////////////////////////////////////////////////////////////////////
/* Windows functions. Setting the cursor with wxSetCursor() did not work in this instance.
   Probably because it's somehow reset from the WndProc() in the child window */
// ŻŻŻŻŻŻŻŻŻŻŻŻŻŻ
#ifdef _WIN32
// Declare a blank icon and one that will be the normal cursor
HCURSOR hCursor = NULL, hCursorBlank = NULL;

// Create the default cursor
void CreateCursor()
{
	hCursor = LoadCursor( NULL, IDC_ARROW );
}

void MSWSetCursor(bool Show)
{
	if(Show)
		SetCursor(hCursor);
	else
	{
		SetCursor(hCursorBlank);
		//wxSetCursor(wxCursor(wxNullCursor));
	}
}

// I could not use FindItemByHWND() instead of this, it crashed on that occation I used it */
HWND MSWGetParent_(HWND Parent)
{
	return GetParent(Parent);
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////



/////////////////////////////////////////////////////////////////////////////////////////////////////////
/* The CPanel class to receive MSWWindowProc messages from the video plugin. */
// ŻŻŻŻŻŻŻŻŻŻŻŻŻŻ
extern CFrame* main_frame;

class CPanel : public wxPanel
{
	public:
		CPanel(
			wxWindow* parent,
			wxWindowID id = wxID_ANY
			);

	private:
		DECLARE_EVENT_TABLE();

		#ifdef _WIN32
			// Receive WndProc messages
			WXLRESULT MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam);
		#endif
};

BEGIN_EVENT_TABLE(CPanel, wxPanel)
END_EVENT_TABLE()

CPanel::CPanel(
			wxWindow *parent,
			wxWindowID id
			)
	: wxPanel(parent, id)
{
}
int abc = 0;
#ifdef _WIN32
	WXLRESULT CPanel::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
	{
		switch (nMsg)
		{
		//case WM_LBUTTONDOWN:
		//case WM_LBUTTONUP:
		//case WM_MOUSEMOVE:
		//	break;		

		// This doesn't work, strange
		//case WM_LBUTTONDBLCLK:
			//PanicAlert("Double click");
			//break;

		case WM_USER:
			switch(wParam)
			{
			// Stop
			case OPENGL_WM_USER_STOP:
				main_frame->DoStop();
				return 0; // Don't bother letting wxWidgets process this at all
			
			case OPENGL_WM_USER_CREATE:
				// We don't have a local setting for bRenderToMain but we can detect it this way instead
				//PanicAlert("main call %i  %i  %i  %i", lParam, (HWND)Core::GetWindowHandle(), MSWGetParent_((HWND)Core::GetWindowHandle()), (HWND)this->GetHWND());
				if (lParam == NULL)
					main_frame->bRenderToMain = false;
				else
					main_frame->bRenderToMain = true;
				return 0;

			case NJOY_RELOAD:
				// DirectInput in nJoy has failed
				Core::ReconnectPad();
				return 0;

			case WIIMOTE_RECONNECT:
				// The Wiimote plugin has been shut down, now reconnect the Wiimote
				//INFO_LOG(CONSOLE, "WIIMOTE_RECONNECT\n");
				Core::ReconnectWiimote();
				return 0;

			// -----------------------------------------
			#ifdef RERECORDING
			// -----------------
				case INPUT_FRAME_COUNTER:
					// Wind back the frame counter after a save state has been loaded
					Core::WindBack((int)lParam);
					return 0;
			#endif
			// -----------------------------
			}
			break;

		//default:
		//	return wxPanel::MSWWindowProc(nMsg, wParam, lParam);
		}
		
		// By default let wxWidgets do what it normally does with this event
		return wxPanel::MSWWindowProc(nMsg, wParam, lParam);
	}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////////////
// 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_CLOSE(CFrame::OnClose)
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_RECORD, CFrame::OnRecord)
EVT_MENU(IDM_PLAYRECORD, CFrame::OnPlayRecording)
EVT_MENU(IDM_STOP, CFrame::OnStop)
EVT_MENU(IDM_FRAMESTEP, CFrame::OnFrameStep)
EVT_MENU(IDM_SCREENSHOT, CFrame::OnScreenshot)
EVT_MENU(IDM_CONFIG_MAIN, CFrame::OnConfigMain)
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_CONFIG_WIIMOTE_PLUGIN, CFrame::OnPluginWiimote)

EVT_AUITOOLBAR_TOOL_DROPDOWN(IDM_SAVE_PERSPECTIVE, CFrame::OnDropDownToolbarItem)
EVT_MENU(IDM_SAVE_PERSPECTIVE, CFrame::OnToolBar)
EVT_MENU(IDM_ADD_PERSPECTIVE, CFrame::OnCreatePerspective)
EVT_MENU(IDM_PERSPECTIVES_ADD_PANE, CFrame::OnToolBar)
EVT_MENU(IDM_EDIT_PERSPECTIVES, CFrame::OnToolBar)
EVT_MENU(IDM_TAB_SPLIT, CFrame::OnToolBar)
EVT_MENU_RANGE(IDM_PERSPECTIVES_0, IDM_PERSPECTIVES_100, CFrame::OnSelectPerspective)

#if defined(HAVE_SFML) && HAVE_SFML
EVT_MENU(IDM_NETPLAY, CFrame::OnNetPlay)
#endif

EVT_MENU(IDM_BROWSE, CFrame::OnBrowse)
EVT_MENU(IDM_MEMCARD, CFrame::OnMemcard)
EVT_MENU(IDM_CHEATS, CFrame::OnShow_CheatsWindow)
EVT_MENU(IDM_INFO, CFrame::OnShow_InfoWindow)
EVT_MENU(IDM_CHANGEDISC, CFrame::OnChangeDisc)
EVT_MENU(IDM_LOAD_WII_MENU, CFrame::OnLoadWiiMenu)
EVT_MENU(IDM_TOGGLE_FULLSCREEN, CFrame::OnToggleFullscreen)
EVT_MENU(IDM_TOGGLE_DUALCORE, CFrame::OnToggleDualCore)
EVT_MENU(IDM_TOGGLE_SKIPIDLE, CFrame::OnToggleSkipIdle)
EVT_MENU(IDM_TOGGLE_TOOLBAR, CFrame::OnToggleToolbar)
EVT_MENU(IDM_TOGGLE_STATUSBAR, CFrame::OnToggleStatusbar)
EVT_MENU(IDM_LOGWINDOW, CFrame::OnToggleLogWindow)
EVT_MENU(IDM_CONSOLEWINDOW, CFrame::OnToggleConsole)

EVT_MENU(IDM_LISTDRIVES, CFrame::GameListChanged)
EVT_MENU(IDM_LISTWII,	 CFrame::GameListChanged)
EVT_MENU(IDM_LISTGC,	 CFrame::GameListChanged)
EVT_MENU(IDM_LISTWAD,	 CFrame::GameListChanged)
EVT_MENU(IDM_LISTJAP,	 CFrame::GameListChanged)
EVT_MENU(IDM_LISTPAL,	 CFrame::GameListChanged)
EVT_MENU(IDM_LISTUSA,	 CFrame::GameListChanged)
EVT_MENU(IDM_PURGECACHE, CFrame::GameListChanged)

EVT_MENU(IDM_LOADLASTSTATE, CFrame::OnLoadLastState)
EVT_MENU(IDM_UNDOLOADSTATE,     CFrame::OnUndoLoadState)
EVT_MENU(IDM_UNDOSAVESTATE,     CFrame::OnUndoSaveState)
EVT_MENU(IDM_LOADSTATEFILE, CFrame::OnLoadStateFromFile)
EVT_MENU(IDM_SAVESTATEFILE, CFrame::OnSaveStateToFile)

EVT_MENU_RANGE(IDM_LOADSLOT1, IDM_LOADSLOT8, CFrame::OnLoadState)
EVT_MENU_RANGE(IDM_SAVESLOT1, IDM_SAVESLOT8, CFrame::OnSaveState)
EVT_MENU_RANGE(IDM_FRAMESKIP0, IDM_FRAMESKIP9, CFrame::OnFrameSkip)
EVT_MENU_RANGE(IDM_DRIVE1, IDM_DRIVE24, CFrame::OnBootDrive)

EVT_SIZE(CFrame::OnResize)
EVT_LIST_ITEM_ACTIVATED(LIST_CTRL, CFrame::OnGameListCtrl_ItemActivated)
EVT_HOST_COMMAND(wxID_ANY, CFrame::OnHostMessage)
#if wxUSE_TIMER
	EVT_TIMER(wxID_ANY, CFrame::OnTimer)
#endif

// Debugger Menu Entries
EVT_MENU(wxID_ANY, CFrame::PostEvent)
EVT_TEXT(wxID_ANY, CFrame::PostEvent)

//EVT_MENU_HIGHLIGHT_ALL(CFrame::PostMenuEvent)
//EVT_UPDATE_UI(wxID_ANY, CFrame::PostUpdateUIEvent)

EVT_AUI_PANE_CLOSE(CFrame::OnPaneClose)
EVT_AUINOTEBOOK_PAGE_CLOSE(wxID_ANY, CFrame::OnNotebookPageClose)
EVT_AUINOTEBOOK_ALLOW_DND(wxID_ANY, CFrame::OnAllowNotebookDnD)
EVT_AUINOTEBOOK_PAGE_CHANGED(wxID_ANY, CFrame::OnNotebookPageChanged)

END_EVENT_TABLE()
/////////////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Creation and close, quit functions
// ŻŻŻŻŻŻŻŻŻŻŻŻŻŻŻŻŻŻŻŻŻ
CFrame::CFrame(bool showLogWindow,
		wxFrame* parent,
		wxWindowID id,
		const wxString& title,
		const wxPoint& pos,
		const wxSize& size,
		bool _UseDebugger,
		long style)
	: wxFrame(parent, id, title, pos, size, style)
	, UseDebugger(_UseDebugger), m_LogWindow(NULL)
	, m_pStatusBar(NULL), bRenderToMain(true), HaveLeds(false)
	, HaveSpeakers(false), m_Panel(NULL), m_ToolBar(NULL), m_ToolBarDebug(NULL)
	, m_bLogWindow(showLogWindow || SConfig::GetInstance().m_InterfaceLogWindow)
	, m_fLastClickTime(0), m_iLastMotionTime(0), LastMouseX(0), LastMouseY(0)
	#if wxUSE_TIMER
		, m_timer(this)
	#endif
          
{
	#ifndef _WIN32
		m_bLogWindow = false;
	#endif

	// Give it a console
	ConsoleListener *Console = LogManager::GetInstance()->getConsoleListener();
	if (SConfig::GetInstance().m_InterfaceConsole) Console->Open();

	// Start debugging mazimized
	if (UseDebugger) this->Maximize(true);
	// Debugger class
	if (UseDebugger)
	{
		g_pCodeWindow = new CCodeWindow(SConfig::GetInstance().m_LocalCoreStartupParameter, this, this);
		g_pCodeWindow->Hide();
		g_pCodeWindow->Load();
	}

	// Create timer
	#if wxUSE_TIMER
		int TimesPerSecond = 10; // We don't need more than this
		m_timer.Start( floor((double)(1000 / TimesPerSecond)) );
	#endif

	// Create toolbar bitmaps	
	InitBitmaps();

	// Give it an icon
	wxIcon IconTemp;
	IconTemp.CopyFromBitmap(wxGetBitmapFromMemory(dolphin_ico32x32));
	SetIcon(IconTemp);

	// Give it a status bar
	m_pStatusBar = CreateStatusBar(1, wxST_SIZEGRIP, ID_STATUSBAR);
	if (!SConfig::GetInstance().m_InterfaceStatusbar)
		m_pStatusBar->Hide();

	// Give it a menu bar
	CreateMenu();

	// -------------------------------------------------------------------------
	// Main panel
	// ŻŻŻŻŻŻŻŻŻŻŻŻŻ
	// This panel is the parent for rendering and it holds the gamelistctrl
	m_Panel = new CPanel(this, IDM_MPANEL);

	m_GameListCtrl = new CGameListCtrl(m_Panel, LIST_CTRL,
			wxDefaultPosition, wxDefaultSize,
			wxLC_REPORT | wxSUNKEN_BORDER | wxLC_ALIGN_LEFT);

	sizerPanel = new wxBoxSizer(wxHORIZONTAL);
	sizerPanel->Add(m_GameListCtrl, 1, wxEXPAND | wxALL);
	m_Panel->SetSizer(sizerPanel);
	// -------------------------------------------------------------------------

	m_Mgr = new wxAuiManager();
	m_Mgr->SetManagedWindow(this);


	DefaultNBStyle = wxAUI_NB_TOP | wxAUI_NB_SCROLL_BUTTONS | wxAUI_NB_TAB_EXTERNAL_MOVE | wxNO_BORDER;
	wxBitmap aNormalFile = wxArtProvider::GetBitmap(wxART_NORMAL_FILE, wxART_OTHER, wxSize(16,16));

	if (UseDebugger)
	{
		m_Mgr->AddPane(m_Panel, wxAuiPaneInfo().Name(wxT("Pane 0")).Caption(wxT("Pane 0")).Show());
	}
	else
	{
		m_Mgr->AddPane(m_Panel, wxAuiPaneInfo().Name(wxT("Pane 0")).Caption(wxT("Pane 0")).Hide());
		m_Mgr->AddPane(CreateEmptyNotebook(), wxAuiPaneInfo().Name(wxT("Pane 1")).Caption(wxT("Pane 1")).Hide());
	}

	// Setup perspectives
	if (UseDebugger)
	{		
		m_Mgr->GetPane(wxT("Pane 0")).CenterPane().PaneBorder(false);
		AuiFullscreen = m_Mgr->SavePerspective();
		m_Mgr->GetPane(wxT("Pane 0")).CenterPane().PaneBorder(true);
	}
	else
	{
		m_Mgr->GetPane(wxT("Pane 0")).Show().PaneBorder(false).CaptionVisible(false).Layer(0).Center();
		AuiFullscreen = m_Mgr->SavePerspective();
	}

	// Create toolbar
	RecreateToolbar();
	if (!SConfig::GetInstance().m_InterfaceToolbar) DoToggleToolbar(false);

	// Create list of available plugins for the configuration window
	CPluginManager::GetInstance().ScanForPlugins();

	// Setup perspectives
	if (UseDebugger)
	{		
		// Load perspective
		std::vector<std::string> VPerspectives;
		std::string _Perspectives;

		IniFile ini;
		ini.Load(DEBUGGER_CONFIG_FILE);
		ini.Get("Perspectives", "Perspectives", &_Perspectives, "");
		ini.Get("Perspectives", "Active", &ActivePerspective, 0);
		SplitString(_Perspectives, ",", VPerspectives);

		//
		for (int i = 0; i < VPerspectives.size(); i++)
		{
			SPerspectives Tmp;		
			std::string _Section, _Perspective, _Width, _Height;
			std::vector<std::string> _SWidth, _SHeight;
			Tmp.Name = VPerspectives.at(i);
			_Section = StringFromFormat("P - %s", Tmp.Name.c_str());
			if (!ini.Exists(_Section.c_str(), "Width")) continue;
			
			ini.Get(_Section.c_str(), "Perspective", &_Perspective, "");
			ini.Get(_Section.c_str(), "Width", &_Width, "");
			ini.Get(_Section.c_str(), "Height", &_Height, "");	

			Tmp.Perspective = wxString::FromAscii(_Perspective.c_str());

			SplitString(_Width, ",", _SWidth);
			SplitString(_Height, ",", _SHeight);
			for (int i = 0; i < _SWidth.size(); i++)
			{
				int _Tmp;
				if (TryParseInt(_SWidth.at(0).c_str(), &_Tmp)) Tmp.Width.push_back(_Tmp);				
			}
			for (int i = 0; i < _SHeight.size(); i++)
			{
				int _Tmp;
				if (TryParseInt(_SHeight.at(0).c_str(), &_Tmp)) Tmp.Height.push_back(_Tmp);
			}
			Perspectives.push_back(Tmp);
		}

		DoLoadPerspective();
	}
	else
	{
		m_Mgr->GetPane(wxT("Pane 1")).Hide().PaneBorder(false).CaptionVisible(false).Layer(0).Right();
	}

	// Show window
	Show();

	if (!UseDebugger)
	{
		SetSimplePaneSize();
		if (m_bLogWindow) DoToggleWindow(IDM_LOGWINDOW, true);
		if (SConfig::GetInstance().m_InterfaceConsole) DoToggleWindow(IDM_CONSOLEWINDOW, true);
	}

	//sizerPanel->SetSizeHints(m_Panel);

	// Commit 
	m_Mgr->Update();

	// Create cursors
	#ifdef _WIN32
		CreateCursor();
	#endif

	// -------------------------
	// Connect event handlers
	// ----------
	wxTheApp->Connect(wxID_ANY, wxEVT_KEY_DOWN, // Keyboard
		wxKeyEventHandler(CFrame::OnKeyDown),
		(wxObject*)0, this);
	wxTheApp->Connect(wxID_ANY, wxEVT_KEY_UP,
		wxKeyEventHandler(CFrame::OnKeyUp),
		(wxObject*)0, this);

	m_Mgr->Connect(wxID_ANY, wxEVT_AUI_RENDER, // Resize
		wxAuiManagerEventHandler(CFrame::OnManagerResize),
		(wxObject*)0, this);	

		wxTheApp->Connect(wxID_ANY, wxEVT_LEFT_DOWN,
			wxMouseEventHandler(CFrame::OnDoubleClick),
			(wxObject*)0, this);
		wxTheApp->Connect(wxID_ANY, wxEVT_MOTION,
			wxMouseEventHandler(CFrame::OnMotion),
			(wxObject*)0, this);
	// ----------

	// Update controls
	UpdateGUI();

	//if we are ever going back to optional iso caching:
	//m_GameListCtrl->Update(SConfig::GetInstance().m_LocalCoreStartupParameter.bEnableIsoCache);
	m_GameListCtrl->Update();

	// If we are rerecording create the status bar now instead of later when a game starts
	#ifdef RERECORDING
		ModifyStatusBar();
		// It's to early for the OnHostMessage(), we will update the status when Ctrl or Space is pressed
		//Core::WriteStatus();
	#endif
}
// Destructor
CFrame::~CFrame()
{
	cdio_free_device_list(drives);
	/* The statbar sample has this so I add this to, but I guess timer will be deleted after
	   this anyway */
	#if wxUSE_TIMER
		if (m_timer.IsRunning()) m_timer.Stop();
	#endif
}

void CFrame::OnQuit(wxCommandEvent& WXUNUSED (event))
{
	Close(true);
}

void CFrame::OnClose(wxCloseEvent& event)
{
	// Don't forget the skip or the window won't be destroyed
	event.Skip();
	// Save GUI settings
	if (UseDebugger) g_pCodeWindow->Save();
	if (UseDebugger) Save();

	if (Core::GetState() != Core::CORE_UNINITIALIZED)
	{
		Core::Stop();
		UpdateGUI();
	}
}

wxPanel* CFrame::CreateEmptyPanel()
{	
   wxPanel* Panel = new wxPanel(this, wxID_ANY);
   return Panel;
}
wxAuiNotebook* CFrame::CreateEmptyNotebook()
{	
   wxAuiNotebook* NB = new wxAuiNotebook(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, DefaultNBStyle);
   return NB;
}


void CFrame::DoFullscreen(bool _F)
{
	ShowFullScreen(_F);
	if (_F)
	{
		// Save the current mode before going to fullscreen
		AuiCurrent = m_Mgr->SavePerspective();
		m_Mgr->LoadPerspective(AuiFullscreen, true);
	}
	else
	{
		// Restore saved perspective
		m_Mgr->LoadPerspective(AuiCurrent, true);
	}
}
int CFrame::Limit(int i, int Low, int High)
{	
	if (i < Low) return Low;
	if (i > High) return High;
	return i;
}
void CFrame::SetSimplePaneSize()
{
	wxArrayInt Pane, Size;
	Pane.Add(0); Size.Add(50);
	Pane.Add(1); Size.Add(50);

	int iClientSize = this->GetSize().GetX();
	// Fix the pane sizes
	for (int i = 0; i < Pane.size(); i++)
	{
		// Check limits
		Size[i] = Limit(Size[i], 5, 95);
		// Produce pixel width from percentage width
		Size[i] = PercentageToPixels(Size[i], iClientSize);
		// Update size
		m_Mgr->GetPane(wxString::Format(wxT("Pane %i"), Pane[i])).BestSize(Size[i], -1).MinSize(Size[i], -1).MaxSize(Size[i], -1);
	}
	m_Mgr->Update();
	for (int i = 0; i < Pane.size(); i++)
	{
		// Remove the size limits
		m_Mgr->GetPane(wxString::Format(wxT("Pane %i"), Pane[i])).MinSize(-1, -1).MaxSize(-1, -1);
	}
}
void CFrame::SetPaneSize()
{
	if (Perspectives.size() <= ActivePerspective) return;
	int iClientX = this->GetSize().GetX(), iClientY = this->GetSize().GetY();

	for (int i = 0, j = 0; i < m_Mgr->GetAllPanes().GetCount(); i++)
	{
		if (!m_Mgr->GetAllPanes().Item(i).window->IsKindOf(CLASSINFO(wxAuiToolBar)))
		{
			if (!m_Mgr->GetAllPanes().Item(i).IsOk()) return;
			if (Perspectives.at(ActivePerspective).Width.size() <= j || Perspectives.at(ActivePerspective).Height.size() <= j) continue;
			int W = Perspectives.at(ActivePerspective).Width.at(j), H = Perspectives.at(ActivePerspective).Height.at(j);
			// Check limits
			W = Limit(W, 5, 95); H = Limit(H, 5, 95);
			// Produce pixel width from percentage width
			W = PercentageToPixels(W, iClientX); H = PercentageToPixels(H, iClientY);
			m_Mgr->GetAllPanes().Item(i).BestSize(W,H).MinSize(W,H).MaxSize(W,H);

			j++;
		}
	}
	m_Mgr->Update();

	for (int i = 0; i < m_Mgr->GetAllPanes().GetCount(); i++)
	{
		if (!m_Mgr->GetAllPanes().Item(i).window->IsKindOf(CLASSINFO(wxAuiToolBar)))
		{
			m_Mgr->GetAllPanes().Item(i).MinSize(-1,-1).MaxSize(-1,-1);
		}
	}
}
// Debugging, show loose windows
void CFrame::ListChildren()
{	
	return;
	ConsoleListener* Console = LogManager::GetInstance()->getConsoleListener();
	for (int i = 0; i < this->GetChildren().size(); i++)
	{
		wxWindow * Win = this->GetChildren().Item(i)->GetData();
		//		Console->Log(LogTypes::LDEBUG, StringFromFormat(
		//	"%i: %s (%s) :: % s\n", i,
		//			Win->GetName().mb_str(), Win->GetLabel().mb_str(), Win->GetParent()->GetName().mb_str()).c_str());
		
		Win = this->GetChildren().Item(i)->GetData();
		for (int j = 0; j < Win->GetChildren().size(); j++)
		{
			//			Console->Log(LogTypes::LDEBUG, StringFromFormat(
			//				"     %i.%i: %s (%s) :: % s\n", i, j,
			//				Win->GetName().mb_str(), Win->GetLabel().mb_str(), Win->GetParent()->GetName().mb_str()).c_str());
		}
	}	
}
void CFrame::ReloadPanes()
{	
	if (ActivePerspective >= Perspectives.size()) ActivePerspective = 0;

	if (Perspectives.size() > 0)
	{
		// Close all pages
		ClosePages();
		// Drop all panes with notebooks
		for (int i = 0; i < m_Mgr->GetAllPanes().GetCount(); i++)
		{
			if (m_Mgr->GetAllPanes().Item(i).window->IsKindOf(CLASSINFO(wxAuiNotebook)))
			{
				// Todo, delete the window instead of just hiding it
				m_Mgr->GetAllPanes().Item(i).window->Hide();
				m_Mgr->DetachPane(m_Mgr->GetAllPanes().Item(i).window);
			}
		}
		// Create new panes with notebooks
		for (int i = 0; i < Perspectives.at(ActivePerspective).Width.size() - 1; i++)
			m_Mgr->AddPane(CreateEmptyNotebook());
		// Names
		NamePanes();
		// Perspectives
		m_Mgr->LoadPerspective(Perspectives.at(ActivePerspective).Perspective, true);
	}
	// Create one pane by default
	else
	{
		m_Mgr->AddPane(CreateEmptyNotebook());
	}

	// Load GUI settings
	g_pCodeWindow->Load();
	// Open notebook pages
	AddRemoveBlankPage();
	g_pCodeWindow->OpenPages();
	if (m_bLogWindow) DoToggleWindow(IDM_LOGWINDOW, true);
	if (SConfig::GetInstance().m_InterfaceConsole) DoToggleWindow(IDM_CONSOLEWINDOW, true);
}
void CFrame::DoLoadPerspective()
{
	ReloadPanes();
	// Restore the exact window sizes, which LoadPerspective doesn't always do
	SetPaneSize();

	/*
	ConsoleListener* Console = LogManager::GetInstance()->getConsoleListener();
	Console->Log(LogTypes::LCUSTOM, StringFromFormat(
		"Loaded: %s, NBs: %i, Non-NBs: %i, \n",
		Perspectives.at(ActivePerspective).Name.c_str(), GetNotebookCount(), m_Mgr->GetAllPanes().GetCount() - GetNotebookCount()).c_str());
	*/
}
void CFrame::Save()
{
	if (Perspectives.size() == 0) return;
	if (ActivePerspective >= Perspectives.size()) ActivePerspective = 0;

	// Turn off edit before saving
	TogglePaneStyle(false);

	// Get client size
	int iClientX = this->GetSize().GetX(), iClientY = this->GetSize().GetY();

	IniFile ini;
	ini.Load(DEBUGGER_CONFIG_FILE);

	std::string _Section = StringFromFormat("P - %s", Perspectives.at(ActivePerspective).Name.c_str());
	ini.Set(_Section.c_str(), "Perspective", m_Mgr->SavePerspective().mb_str());
	
	std::string SWidth = "", SHeight = "";
	for (int i = 0; i < m_Mgr->GetAllPanes().GetCount(); i++)
	{
		if (!m_Mgr->GetAllPanes().Item(i).window->IsKindOf(CLASSINFO(wxAuiToolBar)))
		{
			SWidth += StringFromFormat("%i", PixelsToPercentage(m_Mgr->GetAllPanes().Item(i).window->GetClientSize().GetX(), iClientX));
			SHeight += StringFromFormat("%i", PixelsToPercentage(m_Mgr->GetAllPanes().Item(i).window->GetClientSize().GetY(), iClientY));
			SWidth += ","; SHeight += ",";
		}
	}
	// Remove the ending ","
	SWidth = SWidth.substr(0, SWidth.length()-1); SHeight = SHeight.substr(0, SHeight.length()-1);

	ini.Set(_Section.c_str(), "Width", SWidth.c_str());
	ini.Set(_Section.c_str(), "Height", SHeight.c_str());

	// Save perspective names
	std::string STmp = "";
	for (int i = 0; i < Perspectives.size(); i++)
	{
		STmp += Perspectives.at(i).Name + ",";
	}
	STmp = STmp.substr(0, STmp.length()-1);
	ini.Set("Perspectives", "Perspectives", STmp.c_str());
	ini.Set("Perspectives", "Active", ActivePerspective);
	ini.Save(DEBUGGER_CONFIG_FILE);

	/*
	ConsoleListener* Console = LogManager::GetInstance()->getConsoleListener();
	Console->Log(LogTypes::LCUSTOM, StringFromFormat("Saved: %s\n", Perspectives.at(ActivePerspective).Name.c_str()).c_str());
	*/
	
	TogglePaneStyle(m_ToolBarAui->GetToolToggled(IDM_EDIT_PERSPECTIVES)); 
}

int CFrame::PercentageToPixels(int Percentage, int Total)
{
	int Pixels = (int)((float)Total * ((float)Percentage / 100.0));
	return Pixels;
}
int CFrame::PixelsToPercentage(int Pixels, int Total)
{
	int Percentage = (int)(((float)Pixels / (float)Total) * 100.0);
	return Percentage;
}

void CFrame::NamePanes()
{
	for (int i = 0, j = 0; i < m_Mgr->GetAllPanes().GetCount(); i++)
	{
		if (!m_Mgr->GetAllPanes().Item(i).window->IsKindOf(CLASSINFO(wxAuiToolBar)))
		{
			m_Mgr->GetAllPanes().Item(i).Name(wxString::Format(wxT("Pane %i"), j));
			m_Mgr->GetAllPanes().Item(i).Caption(wxString::Format(wxT("Pane %i"), j));
			j++;
		}
	}
}
void CFrame::AddPane()
{
	m_Mgr->AddPane(CreateEmptyNotebook());
	NamePanes();
	AddRemoveBlankPage();
	m_Mgr->Update();
}	

void CFrame::OnPaneClose(wxAuiManagerEvent& event)
{
	event.Veto();

	wxAuiNotebook * nb = (wxAuiNotebook*)event.pane->window;
	if (!nb) return;
	if (false)
	//if (! (nb->GetPageCount() == 0 || (nb->GetPageCount() == 1 && nb->GetPageText(0).IsSameAs(wxT("<>")))))
	{
		wxMessageBox(wxT("You can't close panes that have pages in them."),
							   wxT("Notice"),
							   wxOK,
							   this);
		
	}
	else
	{
		/*
		ConsoleListener* Console = LogManager::GetInstance()->getConsoleListener();
		Console->Log(LogTypes::LCUSTOM, StringFromFormat("GetNotebookCount before: %i\n", GetNotebookCount()).c_str());
		*/

		// Detach and delete the empty notebook
		m_Mgr->DetachPane(event.pane->window);
		//event.pane->window->Close();
		event.pane->window->Destroy();

		//Console->Log(LogTypes::LCUSTOM, StringFromFormat("GetNotebookCount after: %i\n", GetNotebookCount()).c_str());
	}

	m_Mgr->Update();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Host messages
// ŻŻŻŻŻŻŻŻŻŻŻŻŻŻŻŻŻŻŻŻŻ
#ifdef _WIN32
WXLRESULT CFrame::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
{
	switch (nMsg)
	{
	case WM_SYSCOMMAND:
		switch (wParam & 0xFFF0)
		{
		case SC_SCREENSAVE:
		case SC_MONITORPOWER:
			return 0;
		}
	default:
		// Let wxWidgets process it as normal
		return wxFrame::MSWWindowProc(nMsg, wParam, lParam);
	}
}
#endif

void CFrame::OnHostMessage(wxCommandEvent& event)
{
	switch (event.GetId())
	{
	case IDM_UPDATEGUI:
		UpdateGUI();
		break;

	case IDM_UPDATESTATUSBAR:
		if (m_pStatusBar != NULL)
		{
			m_pStatusBar->SetStatusText(event.GetString(), event.GetInt());
		}
		break;
	}
}

// Post events
// Warning: This may cause an endless loop if the event is propagated back to its parent
void CFrame::PostEvent(wxCommandEvent& event)
{
	event.Skip();
	event.StopPropagation();

	if (g_pCodeWindow
		&& event.GetId() >= IDM_INTERPRETER && event.GetId() <= IDM_ADDRBOX
		&& event.GetId() != IDM_JITUNLIMITED
		)
		wxPostEvent(g_pCodeWindow, event);
}
void CFrame::PostMenuEvent(wxMenuEvent& event)
{
	if (g_pCodeWindow) wxPostEvent(g_pCodeWindow, event);
}
void CFrame::PostUpdateUIEvent(wxUpdateUIEvent& event)
{
	if (g_pCodeWindow) wxPostEvent(g_pCodeWindow, event);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Input
// ŻŻŻŻŻŻŻŻŻŻŻŻŻŻ
void CFrame::OnGameListCtrl_ItemActivated(wxListEvent& WXUNUSED (event))
{
	// Show all platforms and regions if...
	// 1. All platforms are set to hide
	// 2. All Regions are set to hide
	// Otherwise call BootGame to either...
	// 1. Boot the selected iso
	// 2. Boot the default or last loaded iso.
	// 3. Call BrowseForDirectory if the gamelist is empty
	if (!m_GameListCtrl->GetGameNames().size() &&
		!((SConfig::GetInstance().m_ListGC ||
		SConfig::GetInstance().m_ListWii ||
		SConfig::GetInstance().m_ListWad) &&
		(SConfig::GetInstance().m_ListJap ||
		SConfig::GetInstance().m_ListUsa  ||
		SConfig::GetInstance().m_ListPal)))
	{
		SConfig::GetInstance().m_ListGC  =	SConfig::GetInstance().m_ListWii =
		SConfig::GetInstance().m_ListWad =	SConfig::GetInstance().m_ListJap =
		SConfig::GetInstance().m_ListUsa =	SConfig::GetInstance().m_ListPal = true;

		GetMenuBar()->FindItem(IDM_LISTGC)->Check(true);
		GetMenuBar()->FindItem(IDM_LISTWII)->Check(true);
		GetMenuBar()->FindItem(IDM_LISTWAD)->Check(true);
		GetMenuBar()->FindItem(IDM_LISTJAP)->Check(true);
		GetMenuBar()->FindItem(IDM_LISTUSA)->Check(true);
		GetMenuBar()->FindItem(IDM_LISTPAL)->Check(true);

		m_GameListCtrl->Update();
	}			
	else BootGame();
}

void CFrame::OnKeyDown(wxKeyEvent& event)
{
	// Don't block other events
	event.Skip();

	// Escape key turn off fullscreen then Stop emulation in windowed mode
	if (event.GetKeyCode() == WXK_ESCAPE)
	{
		// Temporary solution to double esc keydown. When the OpenGL plugin is running all esc keydowns are duplicated
		// I'm guessing it's coming from the OpenGL plugin but I couldn't find the source of it so I added this until
		// the source of the problem surfaces.
		static double Time = 0;
		if (Common::Timer::GetDoubleTime()-1 < Time) return;
		Time = Common::Timer::GetDoubleTime();

		DoFullscreen(!IsFullScreen());
		if (IsFullScreen())
		{
			#ifdef _WIN32
			MSWSetCursor(true);
			#endif
		}	
		//UpdateGUI();
	}
	if (event.GetKeyCode() == WXK_RETURN && event.GetModifiers() == wxMOD_ALT)
	{
		// For some reasons, wxWidget doesn't proccess the Alt+Enter event there on windows.
		// But still, pressing Alt+Enter make it Fullscreen, So this is for other OS... :P
		DoFullscreen(!IsFullScreen());
	}
#ifdef _WIN32
	if(event.GetKeyCode() == 'M', '3', '4', '5', '6') // Send this to the video plugin WndProc
	{
		PostMessage((HWND)Core::GetWindowHandle(), WM_KEYDOWN, event.GetKeyCode(), 0);
	}
#endif

#ifdef RERECORDING
	// Turn on or off frame advance
	if (event.GetKeyCode() == WXK_CONTROL) Core::FrameStepOnOff();

	// Step forward
	if (event.GetKeyCode() == WXK_SPACE) Core::FrameAdvance();
#endif

	// Send the keyboard status to the Input plugin
	if(Core::GetState() != Core::CORE_UNINITIALIZED)
	    CPluginManager::GetInstance().GetPad(0)->PAD_Input(event.GetKeyCode(), 1); // 1 = Down
}

void CFrame::OnKeyUp(wxKeyEvent& event)
{
	if(Core::GetState() != Core::CORE_UNINITIALIZED)
		CPluginManager::GetInstance().GetPad(0)->PAD_Input(event.GetKeyCode(), 0); // 0 = Up
	event.Skip();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Detect double click. Kind of, for some reason we have to manually create the double click for now.
// ŻŻŻŻŻŻŻŻŻŻŻŻŻŻŻŻ
void CFrame::OnDoubleClick(wxMouseEvent& event)
{
	 // Don't block the mouse click
	event.Skip();

	// Don't use this in Wii mode since we use the mouse as input to the game there
	if (SConfig::GetInstance().m_LocalCoreStartupParameter.bWii) return;

	// Only detect double clicks in the rendering window, and only use this when a game is running
	if(Core::GetState() == Core::CORE_UNINITIALIZED || event.GetId() != IDM_MPANEL) return;

	// For first click just save the time
	if(m_fLastClickTime == 0) { m_fLastClickTime = Common::Timer::GetDoubleTime(); return; }

	// -------------------------------------------
	/* Manually detect double clicks since both wxEVT_LEFT_DCLICK and WM_LBUTTONDBLCLK stops
	   working after the child window is created by the plugin */
	// ----------------------
	double TmpTime = Common::Timer::GetDoubleTime();
	int Elapsed = (TmpTime - m_fLastClickTime) * 1000;

	// Get the double click time, if avaliable
	int DoubleClickTime;
	#ifdef _WIN32
		DoubleClickTime = GetDoubleClickTime();
	#else
		DoubleClickTime = 500; // The default in Windows
	#endif

	m_fLastClickTime = TmpTime; // Save the click time

	if (Elapsed < DoubleClickTime)
	{
		DoFullscreen(!IsFullScreen());
		#ifdef _WIN32
			MSWSetCursor(true); // Show the cursor again, in case it was hidden
		#endif
		m_fLastClickTime -= 10; // Don't treat repeated clicks as double clicks
	}

	UpdateGUI();
}


// Check for mouse motion. Here we process the bHideCursor setting.
// ŻŻŻŻŻŻŻŻŻŻŻŻŻŻŻŻ
void CFrame::OnMotion(wxMouseEvent& event)
{
	event.Skip();

	// The following is only interesting when a game is running
	if(Core::GetState() == Core::CORE_UNINITIALIZED) return;

	/* For some reason WM_MOUSEMOVE events are sent from the plugin even when there is no movement
	   so we have to check that the cursor position has actually changed */
	if(bRenderToMain) //
	{
		bool PositionIdentical = false;
		if (event.GetX() == LastMouseX && event.GetY() == LastMouseY) PositionIdentical = true;
		LastMouseX = event.GetX(); LastMouseY = event.GetY();
		if(PositionIdentical) return;
	}

	// Now we know that we have an actual mouse movement event

	// Update motion for the auto hide option and return
	if(IsFullScreen() && SConfig::GetInstance().m_LocalCoreStartupParameter.bAutoHideCursor)
	{
		m_iLastMotionTime = Common::Timer::GetDoubleTime();
		#ifdef _WIN32
				MSWSetCursor(true);
		#endif
		return;
	}

	if(SConfig::GetInstance().m_LocalCoreStartupParameter.bHideCursor && event.GetId() == IDM_MPANEL)
	{
		#ifdef _WIN32
			if(bRenderToMain) MSWSetCursor(false);

			/* We only need to use this if we are rendering to a separate window. It does work
			   for rendering to the main window to, but in that case our MSWSetCursor() works to
			   so we can use that instead. If we one day determine that the separate window
			   rendering is superfluous we could do without this */
			else PostMessage((HWND)Core::GetWindowHandle(), WM_USER, 10, 0);
		#endif
	}

	// For some reason we need this to, otherwise the cursor can get stuck with the resizing arrows
	else
	{
		#ifdef _WIN32
			if(bRenderToMain) MSWSetCursor(true);
			else PostMessage((HWND)Core::GetWindowHandle(), WM_USER, 10, 1);
		#endif
	}

}

// Check for mouse status a couple of times per second for the auto hide option
// ŻŻŻŻŻŻŻŻŻŻŻŻŻŻŻŻ
#if wxUSE_TIMER
void CFrame::Update()
{
	// Check if auto hide is on, or if we are already hiding the cursor all the time
	if(!SConfig::GetInstance().m_LocalCoreStartupParameter.bAutoHideCursor
		|| SConfig::GetInstance().m_LocalCoreStartupParameter.bHideCursor) return;

	if(IsFullScreen())
	{
		int HideDelay = 1; // Wait 1 second to hide the cursor, just like Windows Media Player
		double TmpSeconds = Common::Timer::GetDoubleTime(); // Get timestamp
		double CompareTime = TmpSeconds - HideDelay; // Compare it

		if(m_iLastMotionTime < CompareTime) // Update cursor
		#ifdef _WIN32
			MSWSetCursor(false);
		#else
			{}
		#endif
	}
}
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////