pcsx2/common/pxEvents.h

/*  PCSX2 - PS2 Emulator for PCs
 *  Copyright (C) 2002-2010  PCSX2 Dev Team
 *
 *  PCSX2 is free software: you can redistribute it and/or modify it under the terms
 *  of the GNU Lesser General Public License as published by the Free Software Found-
 *  ation, either version 3 of the License, or (at your option) any later version.
 *
 *  PCSX2 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 for more details.
 *
 *  You should have received a copy of the GNU General Public License along with PCSX2.
 *  If not, see <http://www.gnu.org/licenses/>.
 */

#pragma once

#include <wx/event.h>
#include "common/General.h"
#include "common/Dependencies.h"
#include "common/Threading.h"

wxDECLARE_EVENT(pxEvt_StartIdleEventTimer, wxCommandEvent);
wxDECLARE_EVENT(pxEvt_DeleteObject, wxCommandEvent);
wxDECLARE_EVENT(pxEvt_DeleteThread, wxCommandEvent);

typedef void FnType_Void();

// --------------------------------------------------------------------------------------
//  SynchronousActionState
// --------------------------------------------------------------------------------------
class SynchronousActionState
{
	DeclareNoncopyableObject(SynchronousActionState);

protected:
	bool m_posted;
	Threading::Semaphore m_sema;
	ScopedExcept m_exception;

public:
	sptr return_value;

	SynchronousActionState()
	{
		m_posted = false;
		return_value = 0;
	}

	virtual ~SynchronousActionState() = default;

	void SetException(const BaseException& ex);
	void SetException(BaseException* ex);

	Threading::Semaphore& GetSemaphore() { return m_sema; }
	const Threading::Semaphore& GetSemaphore() const { return m_sema; }

	void RethrowException() const;
	int WaitForResult();
	int WaitForResult_NoExceptions();
	void PostResult(int res);
	void ClearResult();
	void PostResult();
};


// --------------------------------------------------------------------------------------
//  pxSimpleEvent  -  non-abstract implementation of wxEvent
// --------------------------------------------------------------------------------------
// Why?  I mean, why is wxEvent abstract?  Over-designed OO is such a bad habit.  And while
// I'm on my high horse (and it's so very high!), why use 'private'?  Ever?  Seriously, it
// sucks.  Stop using it, people.
//
class pxSimpleEvent : public wxEvent
{
	wxDECLARE_DYNAMIC_CLASS_NO_ASSIGN(pxSimpleEvent);

public:
	explicit pxSimpleEvent(int evtid = 0)
		: wxEvent(0, evtid)
	{
	}

	pxSimpleEvent(wxWindowID winId, int evtid)
		: wxEvent(winId, evtid)
	{
	}

	pxSimpleEvent(const pxSimpleEvent&) = default;
	virtual wxEvent* Clone() const { return new pxSimpleEvent(*this); }
};

// --------------------------------------------------------------------------------------
//  pxActionEvent
// --------------------------------------------------------------------------------------
class pxActionEvent;

wxDECLARE_EVENT(pxEvt_InvokeAction, pxActionEvent);

class pxActionEvent : public wxEvent
{
	wxDECLARE_DYNAMIC_CLASS_NO_ASSIGN(pxActionEvent);

protected:
	SynchronousActionState* m_state;

public:
	virtual ~pxActionEvent() = default;
	virtual pxActionEvent* Clone() const { return new pxActionEvent(*this); }

	explicit pxActionEvent(SynchronousActionState* sema = NULL, int msgtype = pxEvt_InvokeAction);
	explicit pxActionEvent(SynchronousActionState& sema, int msgtype = pxEvt_InvokeAction);
	pxActionEvent(const pxActionEvent& src);

	Threading::Semaphore* GetSemaphore() const { return m_state ? &m_state->GetSemaphore() : NULL; }

	const SynchronousActionState* GetSyncState() const { return m_state; }
	SynchronousActionState* GetSyncState() { return m_state; }

	void SetSyncState(SynchronousActionState* obj) { m_state = obj; }
	void SetSyncState(SynchronousActionState& obj) { m_state = &obj; }

	virtual void SetException(BaseException* ex);
	void SetException(const BaseException& ex);

	virtual void _DoInvokeEvent();

protected:
	// Extending classes should implement this method to perform whatever action it is
	// the event is supposed to do. :)  Thread affinity is guaranteed to be the Main/UI
	// thread, and exceptions will be handled automatically.
	//
	// Exception note: exceptions are passed back to the thread that posted the event
	// to the queue, when possible.  If the calling thread is not blocking for a result
	// from this event, then the exception will be posted to the Main/UI thread instead.
	virtual void InvokeEvent() {}
};


// --------------------------------------------------------------------------------------
//  pxExceptionEvent
// --------------------------------------------------------------------------------------
class pxExceptionEvent : public pxActionEvent
{
	typedef pxActionEvent _parent;

protected:
	BaseException* m_except;

public:
	pxExceptionEvent(BaseException* ex = NULL)
	{
		m_except = ex;
	}

	pxExceptionEvent(const BaseException& ex);

	virtual ~pxExceptionEvent()
	{
	}

	virtual pxExceptionEvent* Clone() const { return new pxExceptionEvent(*this); }

protected:
	void InvokeEvent();
};

// --------------------------------------------------------------------------------------
//  pxSynchronousCommandEvent
// --------------------------------------------------------------------------------------

class pxSynchronousCommandEvent : public wxCommandEvent
{
	wxDECLARE_DYNAMIC_CLASS_NO_ASSIGN(pxSynchronousCommandEvent);

protected:
	SynchronousActionState* m_sync;
	wxEventType m_realEvent;

public:
	virtual ~pxSynchronousCommandEvent() = default;
	virtual pxSynchronousCommandEvent* Clone() const { return new pxSynchronousCommandEvent(*this); }

	pxSynchronousCommandEvent(SynchronousActionState* sema = NULL, wxEventType commandType = wxEVT_NULL, int winid = 0);
	pxSynchronousCommandEvent(SynchronousActionState& sema, wxEventType commandType = wxEVT_NULL, int winid = 0);

	pxSynchronousCommandEvent(SynchronousActionState* sema, const wxCommandEvent& evt);
	pxSynchronousCommandEvent(SynchronousActionState& sema, const wxCommandEvent& evt);

	pxSynchronousCommandEvent(const pxSynchronousCommandEvent& src);

	Threading::Semaphore* GetSemaphore() { return m_sync ? &m_sync->GetSemaphore() : NULL; }
	wxEventType GetRealEventType() const { return m_realEvent; }

	void SetException(BaseException* ex);
	void SetException(const BaseException& ex);
};

wxDECLARE_EVENT(pxEvt_SynchronousCommand, pxSynchronousCommandEvent);

// --------------------------------------------------------------------------------------
//  BaseMessageBoxEvent
// --------------------------------------------------------------------------------------
class BaseMessageBoxEvent : public pxActionEvent
{
	typedef pxActionEvent _parent;
	wxDECLARE_DYNAMIC_CLASS_NO_ASSIGN(BaseMessageBoxEvent);

protected:
	wxString m_Content;

public:
	virtual ~BaseMessageBoxEvent() = default;
	virtual BaseMessageBoxEvent* Clone() const { return new BaseMessageBoxEvent(*this); }

	explicit BaseMessageBoxEvent(const wxString& content = wxEmptyString, SynchronousActionState* instdata = NULL);
	BaseMessageBoxEvent(const wxString& content, SynchronousActionState& instdata);
	BaseMessageBoxEvent(const BaseMessageBoxEvent& event);

protected:
	virtual void InvokeEvent();
	virtual int _DoDialog() const;
};

// --------------------------------------------------------------------------------------
//  MsgButtons
// --------------------------------------------------------------------------------------
class MsgButtons
{
protected:
	BITFIELD32()
	bool
		m_OK : 1,
		m_Cancel : 1,
		m_Yes : 1,
		m_No : 1,
		m_AllowToAll : 1,
		m_Apply : 1,
		m_Abort : 1,
		m_Retry : 1,
		m_Ignore : 1,
		m_Reset : 1,
		m_Close : 1;
	BITFIELD_END

	wxString m_CustomLabel;
	wxString m_CustomLabelId;

public:
	MsgButtons() { bitset = 0; }

	MsgButtons& OK()
	{
		m_OK = true;
		return *this;
	}
	MsgButtons& Cancel()
	{
		m_Cancel = true;
		return *this;
	}
	MsgButtons& Apply()
	{
		m_Apply = true;
		return *this;
	}
	MsgButtons& Yes()
	{
		m_Yes = true;
		return *this;
	}
	MsgButtons& No()
	{
		m_No = true;
		return *this;
	}
	MsgButtons& ToAll()
	{
		m_AllowToAll = true;
		return *this;
	}

	MsgButtons& Abort()
	{
		m_Abort = true;
		return *this;
	}
	MsgButtons& Retry()
	{
		m_Retry = true;
		return *this;
	}
	MsgButtons& Ignore()
	{
		m_Ignore = true;
		return *this;
	}
	MsgButtons& Reset()
	{
		m_Reset = true;
		return *this;
	}
	MsgButtons& Close()
	{
		m_Close = true;
		return *this;
	}

	// label - native language label displayed to user
	// id - raw ASCII identifier used in the config file (do not translate, hence char*)
	MsgButtons& Custom(const wxString& label, const char* id)
	{
		m_CustomLabel = label;
		m_CustomLabelId = fromUTF8(id);
		return *this;
	}

	MsgButtons& OKCancel()
	{
		m_OK = m_Cancel = true;
		return *this;
	}
	MsgButtons& YesNo()
	{
		m_Yes = m_No = true;
		return *this;
	}

	bool HasOK() const { return m_OK; }
	bool HasCancel() const { return m_Cancel; }
	bool HasApply() const { return m_Apply; }
	bool HasYes() const { return m_Yes; }
	bool HasNo() const { return m_No; }
	bool AllowsToAll() const { return m_AllowToAll; }

	bool HasAbort() const { return m_Abort; }
	bool HasRetry() const { return m_Retry; }
	bool HasIgnore() const { return m_Ignore; }
	bool HasReset() const { return m_Reset; }
	bool HasClose() const { return m_Close; }

	bool HasCustom() const { return !m_CustomLabel.IsEmpty(); }
	const wxString& GetCustomLabel() const { return m_CustomLabel; }
	const wxString& GetCustomLabelId() const { return m_CustomLabelId; }

	bool Allows(wxWindowID id) const;
	void SetBestFocus(wxWindow* dialog) const;
	void SetBestFocus(wxWindow& dialog) const;

	bool operator==(const MsgButtons& right) const
	{
		return OpEqu(bitset);
	}

	bool operator!=(const MsgButtons& right) const
	{
		return !OpEqu(bitset);
	}
};

// --------------------------------------------------------------------------------------
//  pxMessageBoxEvent
// --------------------------------------------------------------------------------------
// This event type is used to transfer message boxes to the main UI thread, and return the
// result of the box.  It's the only way a message box can be issued from non-main threads
// with complete safety in wx2.8.
//
// For simplicity sake this message box only supports two basic designs.  The main design
// is a generic message box with confirmation buttons of your choosing.  Additionally you
// can specify a "scrollableContent" text string, which is added into a read-only richtext
// control similar to the console logs and such.
//
// Future consideration: If wxWidgets 3.0 has improved thread safety, then it should probably
// be reasonable for it to work with a more flexable model where the dialog can be created
// on a child thread, passed to the main thread, where ShowModal() is run (keeping the nested
// message pumps on the main thread where they belong).  But so far this is not possible,
// because of various subtle issues in wx2.8 design.
//
class pxMessageBoxEvent : public BaseMessageBoxEvent
{
	typedef BaseMessageBoxEvent _parent;
	wxDECLARE_DYNAMIC_CLASS_NO_ASSIGN(pxMessageBoxEvent);

protected:
	wxString m_Title;
	MsgButtons m_Buttons;

public:
	virtual ~pxMessageBoxEvent() = default;
	virtual pxMessageBoxEvent* Clone() const { return new pxMessageBoxEvent(*this); }

	pxMessageBoxEvent() {}
	pxMessageBoxEvent(const wxString& title, const wxString& content, const MsgButtons& buttons, SynchronousActionState& instdata);
	pxMessageBoxEvent(const wxString& title, const wxString& content, const MsgButtons& buttons, SynchronousActionState* instdata = NULL);
	pxMessageBoxEvent(const pxMessageBoxEvent& event) = default;

protected:
	int _DoDialog() const;
};

// --------------------------------------------------------------------------------------
//  pxAssertionEvent
// --------------------------------------------------------------------------------------
class pxAssertionEvent : public BaseMessageBoxEvent
{
	typedef BaseMessageBoxEvent _parent;
	wxDECLARE_DYNAMIC_CLASS_NO_ASSIGN(pxAssertionEvent);

protected:
	wxString m_Stacktrace;

public:
	virtual ~pxAssertionEvent() = default;
	virtual pxAssertionEvent* Clone() const { return new pxAssertionEvent(*this); }

	pxAssertionEvent(const wxString& content = wxEmptyString, const wxString& trace = wxEmptyString, SynchronousActionState* instdata = NULL);
	pxAssertionEvent(const wxString& content, const wxString& trace, SynchronousActionState& instdata);
	pxAssertionEvent(const pxAssertionEvent& event) = default;

	pxAssertionEvent& SetStacktrace(const wxString& trace);

protected:
	int _DoDialog() const;
};