X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=src%2FLibCecSharp%2FCecSharpTypes.h;h=0ba3c0481e55922a2a7353c1fe3a338bc2f7febc;hb=f8edb2973d37f3ebfd08291f28be5435d0cf8f64;hp=d6189257294772358f14a75b3fbdb11b8adc22c5;hpb=e4a7396c0e39d6ea8f7b007774407cfd57766a21;p=deb_libcec.git

diff --git a/src/LibCecSharp/CecSharpTypes.h b/src/LibCecSharp/CecSharpTypes.h
index d618925..0ba3c04 100644
--- a/src/LibCecSharp/CecSharpTypes.h
+++ b/src/LibCecSharp/CecSharpTypes.h
@@ -31,10 +31,11 @@
  *     http://www.pulse-eight.net/
  */
 
-#include <windows.h>
+#include "../lib/platform/threads/mutex.h"
 #include <vcclr.h>
 #include <msclr/marshal.h>
 #include "../../include/cec.h"
+#include <vector>
 
 #using <System.dll>
 
@@ -247,19 +248,28 @@ namespace CecSharp
 		F5                          = 0x75,
 		Data                        = 0x76,
 		Max                         = 0x76,
+		SamsungReturn               = 0x91,
 		Unknown
 	};
 
 	public enum class CecVendorId
 	{
-		Samsung   = 0x00F0,
-		LG        = 0xE091,
-		Panasonic = 0x8045,
-		Pioneer   = 0xE036,
-		Onkyo     = 0x09B0,
-		Yamaha    = 0xA0DE,
-		Philips   = 0x903E,
+		Samsung   = 0x0000F0,
+		LG        = 0x00E091,
+		Panasonic = 0x008045,
+		Pioneer   = 0x00E036,
+		Onkyo     = 0x0009B0,
+		Yamaha    = 0x00A0DE,
+		Philips   = 0x00903E,
 		Sony      = 0x080046,
+		Toshiba   = 0x000039,
+		Akai      = 0x0020C7,
+		Benq      = 0x8065E9,
+		Daewoo    = 0x009053,
+		Grundig   = 0x00D0D5,
+		Medion    = 0x000CB8,
+		Sharp     = 0x08001F,
+		Vizio     = 0x6B746D,
 		Unknown   = 0
 	};
 
@@ -354,7 +364,13 @@ namespace CecSharp
 		Version1_5_2  = 0x1502,
 		Version1_5_3  = 0x1503,
 		Version1_6_0  = 0x1600,
-		Version1_6_1  = 0x1601
+		Version1_6_1  = 0x1601,
+		Version1_6_2  = 0x1602,
+		Version1_6_3  = 0x1603,
+		Version1_7_0  = 0x1700,
+		Version1_7_1  = 0x1701,
+		Version1_7_2  = 0x1702,
+		Version1_8_0  = 0x1800
 	};
 
 	public enum class CecServerVersion
@@ -365,7 +381,13 @@ namespace CecSharp
 		Version1_5_2  = 0x1502,
 		Version1_5_3  = 0x1503,
 		Version1_6_0  = 0x1600,
-		Version1_6_1  = 0x1601
+		Version1_6_1  = 0x1601,
+		Version1_6_2  = 0x1602,
+		Version1_6_3  = 0x1603,
+		Version1_7_0  = 0x1700,
+		Version1_7_1  = 0x1701,
+		Version1_7_2  = 0x1702,
+		Version1_8_0  = 0x1800
 	};
 
 	public ref class CecAdapter
@@ -405,6 +427,7 @@ namespace CecSharp
 
 		void Clear(void)
 		{
+			Primary = CecLogicalAddress::Unknown;
 			for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
 				Addresses[iPtr] = CecLogicalAddress::Unknown;
 		}
@@ -417,6 +440,8 @@ namespace CecSharp
 	  void Set(CecLogicalAddress iAddress)
 		{
 			Addresses[(unsigned int)iAddress] = iAddress;
+			if (Primary == CecLogicalAddress::Unknown)
+				Primary = iAddress;
 		}
 
 		property CecLogicalAddress          Primary;
@@ -506,7 +531,7 @@ namespace CecSharp
 	public ref class CecKeypress
 	{
 	public:
-		CecKeypress(int iKeycode, unsigned int iDuration)
+		CecKeypress(CecUserControlCode iKeycode, unsigned int iDuration)
 		{
 			Keycode  = iKeycode;
 			Duration = iDuration;
@@ -515,14 +540,14 @@ namespace CecSharp
 
 		CecKeypress(void)
 		{
-			Keycode  = 0;
+			Keycode  = CecUserControlCode::Unknown;
 			Duration = 0;
 			Empty    = true;
 		}
 
-		property bool         Empty;
-		property int          Keycode;
-		property unsigned int Duration;
+		property bool               Empty;
+		property CecUserControlCode Keycode;
+		property unsigned int       Duration;
 	};
 
 	public ref class CecLogMessage
@@ -580,10 +605,13 @@ namespace CecSharp
 
 			PowerOffScreensaver = CEC_DEFAULT_SETTING_POWER_OFF_SCREENSAVER == 1;
 			PowerOffOnStandby   = CEC_DEFAULT_SETTING_POWER_OFF_ON_STANDBY == 1;
-      SendInactiveSource  = CEC_DEFAULT_SETTING_SEND_INACTIVE_SOURCE == 1;
-      LogicalAddresses    = gcnew CecLogicalAddresses();
-      FirmwareVersion     = 1;
-      PowerOffDevicesOnStandby = CEC_DEFAULT_SETTING_POWER_OFF_DEVICES_STANDBY == 1;
+
+			SendInactiveSource  = CEC_DEFAULT_SETTING_SEND_INACTIVE_SOURCE == 1;
+			LogicalAddresses    = gcnew CecLogicalAddresses();
+			FirmwareVersion     = 1;
+			PowerOffDevicesOnStandby = CEC_DEFAULT_SETTING_POWER_OFF_DEVICES_STANDBY == 1;
+			ShutdownOnStandby   = CEC_DEFAULT_SETTING_SHUTDOWN_ON_STANDBY == 1;
+			DeviceLanguage      = "";
 		}
 
 		void SetCallbacks(CecCallbackMethods ^callbacks)
@@ -624,22 +652,29 @@ namespace CecSharp
 			PowerOffScreensaver = config.bPowerOffScreensaver == 1;
 			PowerOffOnStandby = config.bPowerOffOnStandby == 1;
 
-      if (ServerVersion >= CecServerVersion::Version1_5_1)
-        SendInactiveSource = config.bSendInactiveSource == 1;
+			if (ServerVersion >= CecServerVersion::Version1_5_1)
+				SendInactiveSource = config.bSendInactiveSource == 1;
 
-      if (ServerVersion >= CecServerVersion::Version1_5_3)
-      {
-        LogicalAddresses->Clear();
-			  for (uint8_t iPtr = 0; iPtr <= 16; iPtr++)
-				  if (config.logicalAddresses[iPtr])
-  					LogicalAddresses->Set((CecLogicalAddress)iPtr);
-      }
+			if (ServerVersion >= CecServerVersion::Version1_5_3)
+			{
+				LogicalAddresses->Clear();
+				for (uint8_t iPtr = 0; iPtr <= 16; iPtr++)
+					if (config.logicalAddresses[iPtr])
+						LogicalAddresses->Set((CecLogicalAddress)iPtr);
+			}
 
-      if (ServerVersion >= CecServerVersion::Version1_6_0)
-      {
-        FirmwareVersion          = config.iFirmwareVersion;
-        PowerOffDevicesOnStandby = config.bPowerOffDevicesOnStandby == 1;
-      }
+			if (ServerVersion >= CecServerVersion::Version1_6_0)
+			{
+				FirmwareVersion          = config.iFirmwareVersion;
+				PowerOffDevicesOnStandby = config.bPowerOffDevicesOnStandby == 1;
+				ShutdownOnStandby        = config.bShutdownOnStandby == 1;
+			}
+
+			if (ServerVersion >= CecServerVersion::Version1_6_2)
+				DeviceLanguage = gcnew System::String(config.strDeviceLanguage);
+
+			if (ServerVersion >= CecServerVersion::Version1_6_3)
+			  MonitorOnlyClient = config.bMonitorOnly == 1;
 		}
 
 		property System::String ^     DeviceName;
@@ -660,11 +695,13 @@ namespace CecSharp
 		property CecLogicalAddresses ^PowerOffDevices;
 		property bool                 PowerOffScreensaver;
 		property bool                 PowerOffOnStandby;
-    property bool                 SendInactiveSource;
-    property CecLogicalAddresses ^LogicalAddresses;
-    property uint16_t             FirmwareVersion;
-    property bool                 PowerOffDevicesOnStandby;
-
+		property bool                 SendInactiveSource;
+		property CecLogicalAddresses ^LogicalAddresses;
+		property uint16_t             FirmwareVersion;
+		property bool                 PowerOffDevicesOnStandby;
+		property bool                 ShutdownOnStandby;
+		property bool                 MonitorOnlyClient;
+		property System::String ^     DeviceLanguage;
 		property CecCallbackMethods ^ Callbacks;
 	};
 
@@ -676,56 +713,127 @@ namespace CecSharp
 	typedef int (__stdcall *COMMANDCB)(const CEC::cec_command &command);
 	typedef int (__stdcall *CONFIGCB) (const CEC::libcec_configuration &config);
 	typedef int (__stdcall *ALERTCB)  (const CEC::libcec_alert, const CEC::libcec_parameter &data);
+	typedef int (__stdcall *MENUCB)   (const CEC::cec_menu_state newVal);
+	typedef void (__stdcall *ACTICB)  (const CEC::cec_logical_address logicalAddress, const uint8_t bActivated);
 
-	static LOGCB              g_logCB;
-	static KEYCB              g_keyCB;
-	static COMMANDCB          g_commandCB;
-	static CONFIGCB           g_configCB;
-	static ALERTCB            g_alertCB;
-	static CEC::ICECCallbacks g_cecCallbacks;
+	typedef struct
+	{
+		LOGCB     logCB;
+		KEYCB     keyCB;
+		COMMANDCB commandCB;
+		CONFIGCB  configCB;
+		ALERTCB   alertCB;
+		MENUCB    menuCB;
+		ACTICB    sourceActivatedCB;
+	} UnmanagedCecCallbacks;
+
+	static PLATFORM::CMutex                   g_callbackMutex;
+	static std::vector<UnmanagedCecCallbacks> g_unmanagedCallbacks;
+  static CEC::ICECCallbacks                 g_cecCallbacks;
 
 	int CecLogMessageCB(void *cbParam, const CEC::cec_log_message &message)
 	{
-		if (g_logCB)
-			return g_logCB(message);
+		if (cbParam)
+		{
+			size_t iPtr = (size_t)cbParam;
+			PLATFORM::CLockObject lock(g_callbackMutex);
+			if (iPtr >= 0 && iPtr < g_unmanagedCallbacks.size())
+				return g_unmanagedCallbacks[iPtr].logCB(message);
+		}
 		return 0;
 	}
 
 	int CecKeyPressCB(void *cbParam, const CEC::cec_keypress &key)
 	{
-		if (g_keyCB)
-			return g_keyCB(key);
+		if (cbParam)
+		{
+			size_t iPtr = (size_t)cbParam;
+			PLATFORM::CLockObject lock(g_callbackMutex);
+			if (iPtr >= 0 && iPtr < g_unmanagedCallbacks.size())
+				return g_unmanagedCallbacks[iPtr].keyCB(key);
+		}
 		return 0;
 	}
 
 	int CecCommandCB(void *cbParam, const CEC::cec_command &command)
 	{
-		if (g_commandCB)
-			return g_commandCB(command);
+		if (cbParam)
+		{
+			size_t iPtr = (size_t)cbParam;
+			PLATFORM::CLockObject lock(g_callbackMutex);
+			if (iPtr >= 0 && iPtr < g_unmanagedCallbacks.size())
+				return g_unmanagedCallbacks[iPtr].commandCB(command);
+		}
 		return 0;
 	}
 
   int CecConfigCB(void *cbParam, const CEC::libcec_configuration &config)
 	{
-		if (g_configCB)
-			return g_configCB(config);
+		if (cbParam)
+		{
+			size_t iPtr = (size_t)cbParam;
+			PLATFORM::CLockObject lock(g_callbackMutex);
+			if (iPtr >= 0 && iPtr < g_unmanagedCallbacks.size())
+				return g_unmanagedCallbacks[iPtr].configCB(config);
+		}
 		return 0;
 	}
 
 	int CecAlertCB(void *cbParam, const CEC::libcec_alert alert, const CEC::libcec_parameter &data)
 	{
-		if (g_alertCB)
-			return g_alertCB(alert, data);
+		if (cbParam)
+		{
+			size_t iPtr = (size_t)cbParam;
+			PLATFORM::CLockObject lock(g_callbackMutex);
+			if (iPtr >= 0 && iPtr < g_unmanagedCallbacks.size())
+				return g_unmanagedCallbacks[iPtr].alertCB(alert, data);
+		}
 		return 0;
 	}
 
+	int CecMenuCB(void *cbParam, const CEC::cec_menu_state newVal)
+	{
+		if (cbParam)
+		{
+			size_t iPtr = (size_t)cbParam;
+			PLATFORM::CLockObject lock(g_callbackMutex);
+			if (iPtr >= 0 && iPtr < g_unmanagedCallbacks.size())
+				return g_unmanagedCallbacks[iPtr].menuCB(newVal);
+		}
+		return 0;
+	}
+
+	void CecSourceActivatedCB(void *cbParam, const CEC::cec_logical_address logicalAddress, const uint8_t bActivated)
+	{
+		if (cbParam)
+		{
+			size_t iPtr = (size_t)cbParam;
+			PLATFORM::CLockObject lock(g_callbackMutex);
+			if (iPtr >= 0 && iPtr < g_unmanagedCallbacks.size())
+				g_unmanagedCallbacks[iPtr].sourceActivatedCB(logicalAddress, bActivated);
+		}
+	}
+
 	#pragma managed
 	// delegates for the unmanaged callback methods
-	public delegate int CecLogMessageManagedDelegate(const CEC::cec_log_message &);
-	public delegate int CecKeyPressManagedDelegate(const CEC::cec_keypress &);
-	public delegate int CecCommandManagedDelegate(const CEC::cec_command &);
-	public delegate int CecConfigManagedDelegate(const CEC::libcec_configuration &);
-	public delegate int CecAlertManagedDelegate(const CEC::libcec_alert, const CEC::libcec_parameter &);
+	public delegate int  CecLogMessageManagedDelegate(const CEC::cec_log_message &);
+	public delegate int  CecKeyPressManagedDelegate(const CEC::cec_keypress &);
+	public delegate int  CecCommandManagedDelegate(const CEC::cec_command &);
+	public delegate int  CecConfigManagedDelegate(const CEC::libcec_configuration &);
+	public delegate int  CecAlertManagedDelegate(const CEC::libcec_alert, const CEC::libcec_parameter &);
+	public delegate int  CecMenuManagedDelegate(const CEC::cec_menu_state newVal);
+	public delegate void CecSourceActivatedManagedDelegate(const CEC::cec_logical_address logicalAddress, const uint8_t bActivated);
+
+	void AssignCallbacks()
+	{
+		g_cecCallbacks.CBCecLogMessage           = CecLogMessageCB;
+		g_cecCallbacks.CBCecKeyPress             = CecKeyPressCB;
+		g_cecCallbacks.CBCecCommand              = CecCommandCB;
+		g_cecCallbacks.CBCecConfigurationChanged = CecConfigCB;
+		g_cecCallbacks.CBCecAlert                = CecAlertCB;
+		g_cecCallbacks.CBCecMenuStateChanged     = CecMenuCB;
+    g_cecCallbacks.CBCecSourceActivated      = CecSourceActivatedCB;
+	}
 
 	// callback method interface
 	public ref class CecCallbackMethods
@@ -733,14 +841,22 @@ namespace CecSharp
 	public:
     CecCallbackMethods(void)
     {
+			m_iCallbackPtr = -1;
+			AssignCallbacks();
       m_bHasCallbacks = false;
       m_bDelegatesCreated = false;
     }
 
-	~CecCallbackMethods(void)
-   {
-     DestroyDelegates();
-   }
+	  ~CecCallbackMethods(void)
+    {
+      DestroyDelegates();
+    }
+
+		size_t GetCallbackPtr(void)
+		{
+			PLATFORM::CLockObject lock(g_callbackMutex);
+			return m_iCallbackPtr;
+		}
 
 	protected:
    !CecCallbackMethods(void)
@@ -792,6 +908,15 @@ namespace CecSharp
 			return 0;
 		}
 
+		virtual int ReceiveMenuStateChange(CecMenuState newVal)
+		{
+			return 0;
+		}
+
+		virtual void SourceActivated(CecLogicalAddress logicalAddress, bool bActivated)
+		{
+		}
+
 	protected:
 		// managed callback methods
 		int CecLogMessageManaged(const CEC::cec_log_message &message)
@@ -806,7 +931,7 @@ namespace CecSharp
 		{
 			int iReturn(0);
 			if (m_bHasCallbacks)
-				iReturn = m_callbacks->ReceiveKeypress(gcnew CecKeypress(key.keycode, key.duration));
+				iReturn = m_callbacks->ReceiveKeypress(gcnew CecKeypress((CecUserControlCode)key.keycode, key.duration));
 			return iReturn;
 		}
 
@@ -851,6 +976,22 @@ namespace CecSharp
 			return iReturn;
 		}
 
+		int CecMenuManaged(const CEC::cec_menu_state newVal)
+		{
+			int iReturn(0);
+			if (m_bHasCallbacks)
+			{
+				iReturn = m_callbacks->ReceiveMenuStateChange((CecMenuState)newVal);
+			}
+			return iReturn;
+		}
+
+		void CecSourceActivatedManaged(const CEC::cec_logical_address logicalAddress, const uint8_t bActivated)
+		{
+			if (m_bHasCallbacks)
+				m_callbacks->SourceActivated((CecLogicalAddress)logicalAddress, bActivated == 1);
+		}
+
 		void DestroyDelegates()
 		{
       m_bHasCallbacks = false;
@@ -860,6 +1001,9 @@ namespace CecSharp
 				m_logMessageGCHandle.Free();
 				m_keypressGCHandle.Free();
 				m_commandGCHandle.Free();
+				m_alertGCHandle.Free();
+				m_menuGCHandle.Free();
+				m_sourceActivatedGCHandle.Free();
 			}
 		}
 
@@ -872,37 +1016,55 @@ namespace CecSharp
         msclr::interop::marshal_context ^ context = gcnew msclr::interop::marshal_context();
 
         // create the delegate method for the log message callback
-        m_logMessageDelegate           = gcnew CecLogMessageManagedDelegate(this, &CecCallbackMethods::CecLogMessageManaged);
-        m_logMessageGCHandle           = System::Runtime::InteropServices::GCHandle::Alloc(m_logMessageDelegate);
-        g_logCB                        = static_cast<LOGCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_logMessageDelegate).ToPointer());
-        g_cecCallbacks.CBCecLogMessage = CecLogMessageCB;
+        m_logMessageDelegate      = gcnew CecLogMessageManagedDelegate(this, &CecCallbackMethods::CecLogMessageManaged);
+        m_logMessageGCHandle      = System::Runtime::InteropServices::GCHandle::Alloc(m_logMessageDelegate);
+				m_logMessageCallback      = static_cast<LOGCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_logMessageDelegate).ToPointer());
 
         // create the delegate method for the keypress callback
-        m_keypressDelegate           = gcnew CecKeyPressManagedDelegate(this, &CecCallbackMethods::CecKeyPressManaged);
-        m_keypressGCHandle           = System::Runtime::InteropServices::GCHandle::Alloc(m_keypressDelegate);
-        g_keyCB                      = static_cast<KEYCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_keypressDelegate).ToPointer());
-        g_cecCallbacks.CBCecKeyPress = CecKeyPressCB;
+        m_keypressDelegate        = gcnew CecKeyPressManagedDelegate(this, &CecCallbackMethods::CecKeyPressManaged);
+        m_keypressGCHandle        = System::Runtime::InteropServices::GCHandle::Alloc(m_keypressDelegate);
+				m_keypressCallback        = static_cast<KEYCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_keypressDelegate).ToPointer());
 
         // create the delegate method for the command callback
-        m_commandDelegate           = gcnew CecCommandManagedDelegate(this, &CecCallbackMethods::CecCommandManaged);
-        m_commandGCHandle           = System::Runtime::InteropServices::GCHandle::Alloc(m_commandDelegate);
-        g_commandCB                 = static_cast<COMMANDCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_commandDelegate).ToPointer());
-        g_cecCallbacks.CBCecCommand = CecCommandCB;
+        m_commandDelegate         = gcnew CecCommandManagedDelegate(this, &CecCallbackMethods::CecCommandManaged);
+        m_commandGCHandle         = System::Runtime::InteropServices::GCHandle::Alloc(m_commandDelegate);
+				m_commandCallback         = static_cast<COMMANDCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_commandDelegate).ToPointer());
 
         // create the delegate method for the configuration change callback
-        m_configDelegate            = gcnew CecConfigManagedDelegate(this, &CecCallbackMethods::CecConfigManaged);
-        m_configGCHandle            = System::Runtime::InteropServices::GCHandle::Alloc(m_configDelegate);
-        g_configCB                  = static_cast<CONFIGCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_configDelegate).ToPointer());
-        g_cecCallbacks.CBCecConfigurationChanged = CecConfigCB;
+        m_configDelegate          = gcnew CecConfigManagedDelegate(this, &CecCallbackMethods::CecConfigManaged);
+        m_configGCHandle          = System::Runtime::InteropServices::GCHandle::Alloc(m_configDelegate);
+				m_configCallback          = static_cast<CONFIGCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_configDelegate).ToPointer());
 
         // create the delegate method for the alert callback
-        m_alertDelegate            = gcnew CecAlertManagedDelegate(this, &CecCallbackMethods::CecAlertManaged);
-        m_alertGCHandle            = System::Runtime::InteropServices::GCHandle::Alloc(m_alertDelegate);
-        g_alertCB                  = static_cast<ALERTCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_alertDelegate).ToPointer());
-        g_cecCallbacks.CBCecAlert  = CecAlertCB;
+        m_alertDelegate           = gcnew CecAlertManagedDelegate(this, &CecCallbackMethods::CecAlertManaged);
+        m_alertGCHandle           = System::Runtime::InteropServices::GCHandle::Alloc(m_alertDelegate);
+				m_alertCallback           = static_cast<ALERTCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_alertDelegate).ToPointer());
+
+        // create the delegate method for the menu callback
+        m_menuDelegate            = gcnew CecMenuManagedDelegate(this, &CecCallbackMethods::CecMenuManaged);
+        m_menuGCHandle            = System::Runtime::InteropServices::GCHandle::Alloc(m_menuDelegate);
+				m_menuCallback            = static_cast<MENUCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_menuDelegate).ToPointer());
+
+			  // create the delegate method for the source activated callback
+        m_sourceActivatedDelegate = gcnew CecSourceActivatedManagedDelegate(this, &CecCallbackMethods::CecSourceActivatedManaged);
+        m_sourceActivatedGCHandle = System::Runtime::InteropServices::GCHandle::Alloc(m_sourceActivatedDelegate);
+				m_sourceActivatedCallback = static_cast<ACTICB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_sourceActivatedDelegate).ToPointer());
 
         delete context;
-        m_bDelegatesCreated = true;
+
+				UnmanagedCecCallbacks unmanagedCallbacks;
+				unmanagedCallbacks.logCB             = m_logMessageCallback;
+				unmanagedCallbacks.keyCB             = m_keypressCallback;
+				unmanagedCallbacks.commandCB         = m_commandCallback;
+				unmanagedCallbacks.configCB          = m_configCallback;
+				unmanagedCallbacks.alertCB           = m_alertCallback;
+				unmanagedCallbacks.menuCB            = m_menuCallback;
+				unmanagedCallbacks.sourceActivatedCB = m_sourceActivatedCallback;
+
+				PLATFORM::CLockObject lock(g_callbackMutex);
+				g_unmanagedCallbacks.push_back(unmanagedCallbacks);
+				m_iCallbackPtr = g_unmanagedCallbacks.size() - 1;
+				m_bDelegatesCreated = true;
       }
     }
 
@@ -924,10 +1086,19 @@ namespace CecSharp
 
 		CecAlertManagedDelegate ^                         m_alertDelegate;
 		static System::Runtime::InteropServices::GCHandle m_alertGCHandle;
-		CONFIGCB                                          m_alertCallback;
+		ALERTCB                                           m_alertCallback;
+
+		CecMenuManagedDelegate ^                          m_menuDelegate;
+		static System::Runtime::InteropServices::GCHandle m_menuGCHandle;
+		MENUCB                                            m_menuCallback;
+
+		CecSourceActivatedManagedDelegate ^               m_sourceActivatedDelegate;
+		static System::Runtime::InteropServices::GCHandle m_sourceActivatedGCHandle;
+		ACTICB                                            m_sourceActivatedCallback;
 
 		CecCallbackMethods ^ m_callbacks;
 	  bool                 m_bHasCallbacks;
     bool                 m_bDelegatesCreated;
+		size_t               m_iCallbackPtr;
 	};
 }