3 * This file is part of the libCEC(R) library.
5 * libCEC(R) is Copyright (C) 2011-2013 Pulse-Eight Limited. All rights reserved.
6 * libCEC(R) is an original work, containing original code.
8 * libCEC(R) is a trademark of Pulse-Eight Limited.
10 * This program is dual-licensed; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25 * Alternatively, you can license this library under a commercial license,
26 * please contact Pulse-Eight Licensing for more information.
28 * For more information contact:
29 * Pulse-Eight Licensing <license@pulse-eight.com>
30 * http://www.pulse-eight.com/
31 * http://www.pulse-eight.net/
34 #include "../lib/platform/threads/mutex.h"
36 #include <msclr/marshal.h>
37 #include "../../include/cec.h"
43 /// LibCecSharp namespace
45 /// <see cref="LibCecSharp" />
49 /// The device type. For client applications, libCEC only supports RecordingDevice, PlaybackDevice or Tuner.
50 /// libCEC uses RecordingDevice by default.
52 public enum class CecDeviceType
63 /// Reserved / do not use
75 /// Audio system / AVR
81 /// Log level that can be used by the logging callback method to filter messages from libCEC.
83 public enum class CecLogLevel
90 /// libCEC encountered a serious problem, and couldn't complete an action.
94 /// libCEC warns that it encountered a problem, but recovered.
98 /// libCEC informs the client about a CEC state change.
102 /// Raw CEC data traffic
106 /// Debugging messages
110 /// Display all messages
116 /// A logical address on the CEC bus
118 public enum class CecLogicalAddress
121 /// Not a valid logical address
129 /// Recording device 1
131 RecordingDevice1
= 1,
133 /// Recording device 2
135 RecordingDevice2
= 2,
141 /// Playback device 1
145 /// Audio system / AVR
157 /// Playback device 2
161 /// Recording device 3
163 RecordingDevice3
= 9,
169 /// Playback device 3
171 PlaybackDevice3
= 11,
173 /// Reserved address 1
177 /// Reserved address 2
185 /// Unregistered / new device
189 /// Broadcast address
195 /// The type of alert when libCEC calls the CecAlert callback
197 public enum class CecAlert
200 /// The device needs servicing. This is set when the firmware can be upgraded, or when a problem with the firmware is detected.
201 /// The latest firmware flash tool can be downloaded from http://packages.pulse-eight.net/
205 /// The connection to the adapter was lost, probably because the device got unplugged.
209 /// No permission from the OS to access the adapter.
213 /// The device is being used by another program.
217 /// The physical address that is assigned to the adapter is already being used.
219 PhysicalAddressError
,
221 /// The TV does not respond to polls.
227 /// The type of parameter that is sent with the CecAlert callback
229 public enum class CecParameterType
232 /// The parameter is a string
234 ParameterTypeString
= 1
238 /// A parameter for the CecAlert callback
240 public ref
class CecParameter
244 /// Create a new parameter
246 /// <param name="type">The type of this parameter.</param>
247 /// <param name="data">The value of this parameter.</param>
248 CecParameter(CecParameterType type
, System::String
^ data
)
255 /// The type of this parameter
257 property CecParameterType Type
;
259 /// The value of this parameter
261 property
System::String
^ Data
;
265 /// The power status of a CEC device
267 public enum class CecPowerStatus
278 /// In transition from standby to on
280 InTransitionStandbyToOn
= 0x02,
282 /// In transition from on to standby
284 InTransitionOnToStandby
= 0x03,
292 /// The CEC version of a CEC device
294 public enum class CecVersion
323 /// Parameter for OSD string display, that controls how to display the string
325 public enum class CecDisplayControl
328 /// Display for the default time
330 DisplayForDefaultTime
= 0x00,
332 /// Display until it is cleared by ClearPreviousMessage
334 DisplayUntilCleared
= 0x40,
336 /// Clear message displayed by DisplayUntilCleared
338 ClearPreviousMessage
= 0x80,
340 /// Reserved / do not use
342 ReservedForFutureUse
= 0xC0
346 /// The menu state of a CEC device
348 public enum class CecMenuState
361 /// Deck control mode for playback and recording devices
363 public enum class CecDeckControlMode
366 /// Skip forward / wind
370 /// Skip reverse / rewind
372 SkipReverseRewind
= 2,
384 /// Deck status for playback and recording devices
386 public enum class CecDeckInfo
401 /// Showing still frame
409 /// Playing slow reverse
421 /// No media detected
425 /// Stop / not playing
429 /// Skip forward / wind
431 SkipForwardWind
= 0x1B,
433 /// Skip reverse / rewind
435 SkipReverseRewind
= 0x1C,
437 /// Index search forward
439 IndexSearchForward
= 0x1D,
441 /// Index search reverse
443 IndexSearchReverse
= 0x1E,
445 /// Other / unknown status
451 /// User control code, the key code when the user presses or releases a button on the remote.
452 /// Used by SendKeypress() and the CecKey callback.
454 public enum class CecUserControlCode
477 /// Direction right + up
481 /// Direction right + down
485 /// Direction left + up
489 /// Direction left + down
579 PreviousChannel
= 0x32,
581 /// Select sound track
589 /// Display information
591 DisplayInformation
= 0x35,
605 /// Toggle powered on / standby
669 /// Toggle sub picture
673 /// Toggle video on demand
675 VideoOnDemand
= 0x52,
677 /// Toggle electronic program guide (EPG)
679 ElectronicProgramGuide
= 0x53,
681 /// Toggle timer programming
683 TimerProgramming
= 0x54,
685 /// Set initial configuration
687 InitialConfiguration
= 0x55,
689 /// Start playback function
693 /// Pause playback function
695 PausePlayFunction
= 0x61,
697 /// Toggle recording function
699 RecordFunction
= 0x62,
701 /// Pause recording function
703 PauseRecordFunction
= 0x63,
705 /// Stop playback function
709 /// Mute audio function
713 /// Restore volume function
715 RestoreVolumeFunction
= 0x66,
721 /// Select media function
723 SelectMediaFunction
= 0x68,
725 /// Select AV input function
727 SelectAVInputFunction
= 0x69,
729 /// Select audio input function
731 SelectAudioInputFunction
= 0x6A,
733 /// Toggle powered on / standby function
735 PowerToggleFunction
= 0x6B,
737 /// Power off function
739 PowerOffFunction
= 0x6C,
741 /// Power on function
743 PowerOnFunction
= 0x6D,
753 /// F3 / green button
757 /// F4 / yellow button
769 /// Max. valid key code for standard buttons
773 /// Extra return button on Samsung remotes
775 SamsungReturn
= 0x91,
777 /// Unknown / invalid key code
783 /// Vendor IDs for CEC devices
785 public enum class CecVendorId
795 PulseEight
= 0x001582,
796 HarmanKardon2
= 0x001950,
799 Panasonic
= 0x008045,
811 HarmanKardon
= 0x9C645E,
816 /// Audio status of audio system / AVR devices
818 public enum class CecAudioStatus
823 MuteStatusMask
= 0x80,
825 /// Not muted, volume status mask
827 VolumeStatusMask
= 0x7F,
839 VolumeStatusUnknown
= 0x7F
843 /// CEC opcodes, as described in the HDMI CEC specification
845 public enum class CecOpcode
852 /// Image view on: power on display for image display
856 /// Text view on: power on display for text display
860 /// Device no longer is the active source
862 InactiveSource
= 0x9D,
864 /// Request which device has the active source status
866 RequestActiveSource
= 0x85,
868 /// Routing change for HDMI switches
870 RoutingChange
= 0x80,
872 /// Routing information for HDMI switches
874 RoutingInformation
= 0x81,
876 /// Change the stream path to the given physical address
878 SetStreamPath
= 0x86,
880 /// Inform that a device went into standby mode
892 /// Recording status information
896 /// Record current display
898 RecordTvScreen
= 0x0F,
900 /// Clear analogue timer
902 ClearAnalogueTimer
= 0x33,
904 /// Clear digital timer
906 ClearDigitalTimer
= 0x99,
908 /// Clear external timer
910 ClearExternalTimer
= 0xA1,
912 /// Set analogue timer
914 SetAnalogueTimer
= 0x34,
916 /// Set digital timer
918 SetDigitalTimer
= 0x97,
920 /// Set external timer
922 SetExternalTimer
= 0xA2,
924 /// Set program title of a timer
926 SetTimerProgramTitle
= 0x67,
928 /// Timer status cleared
930 TimerClearedStatus
= 0x43,
932 /// Timer status information
936 /// CEC version used by a device
940 /// Request CEC version of a device
942 GetCecVersion
= 0x9F,
944 /// Request physical address of a device
946 GivePhysicalAddress
= 0x83,
948 /// Request language code of the menu language of a device
949 /// 3 character ISO 639-2 country code. see http://http://www.loc.gov/standards/iso639-2/
951 GetMenuLanguage
= 0x91,
953 /// Report the physical address
955 ReportPhysicalAddress
= 0x84,
957 /// Report the language code of the menu language
958 /// 3 character ISO 639-2 country code. see http://http://www.loc.gov/standards/iso639-2/
960 SetMenuLanguage
= 0x32,
962 /// Deck control for playback and recording devices
966 /// Deck status for playback and recording devices
970 /// Request deck status from playback and recording devices
972 GiveDeckStatus
= 0x1A,
974 /// Start playback on playback and recording devices
978 /// Request tuner status
980 GiveTunerDeviceStatus
= 0x08,
982 /// Select analogue service on a tuner
984 SelectAnalogueService
= 0x92,
986 /// Select digital service on a tuner
988 SelectDigtalService
= 0x93,
990 /// Report tuner device status
992 TunerDeviceStatus
= 0x07,
994 /// Tuner step decrement
996 TunerStepDecrement
= 0x06,
998 /// Tuner step increment
1000 TunerStepIncrement
= 0x05,
1002 /// Report device vendor ID
1004 DeviceVendorId
= 0x87,
1006 /// Request device vendor ID
1008 GiveDeviceVendorId
= 0x8C,
1010 /// Vendor specific command
1012 VendorCommand
= 0x89,
1014 /// Vendor specific command with vendor ID
1016 VendorCommandWithId
= 0xA0,
1018 /// Vendor specific remote button pressed
1020 VendorRemoteButtonDown
= 0x8A,
1022 /// Vendor specific remote button released
1024 VendorRemoteButtonUp
= 0x8B,
1026 /// Display / clear OSD string
1028 SetOsdString
= 0x64,
1030 /// Request device OSD name
1034 /// Report device OSD name
1038 /// Request device menu status
1042 /// Report device menu status
1046 /// Remote button pressed
1048 UserControlPressed
= 0x44,
1050 /// Remote button released
1052 UserControlRelease
= 0x45,
1054 /// Request device power status
1056 GiveDevicePowerStatus
= 0x8F,
1058 /// Report device power status
1060 ReportPowerStatus
= 0x90,
1062 /// Feature abort / unsupported command
1064 FeatureAbort
= 0x00,
1070 /// Give audio status
1072 GiveAudioStatus
= 0x71,
1074 /// Give audiosystem mode
1076 GiveSystemAudioMode
= 0x7D,
1078 /// Report device audio status
1080 ReportAudioStatus
= 0x7A,
1082 /// Set audiosystem mode
1084 SetSystemAudioMode
= 0x72,
1086 /// Request audiosystem mode
1088 SystemAudioModeRequest
= 0x70,
1090 /// Report audiosystem mode
1092 SystemAudioModeStatus
= 0x7E,
1094 /// Set audio bitrate
1096 SetAudioRate
= 0x9A,
1098 /// When this opcode is set, no opcode will be sent to the device / poll message
1099 /// This is one of the reserved numbers
1105 /// Audiosystem status
1107 public enum class CecSystemAudioStatus
1120 /// libCEC client application version
1122 public enum class CecClientVersion
1131 Version1_5_0
= 0x1500,
1135 Version1_5_1
= 0x1501,
1139 Version1_5_2
= 0x1502,
1143 Version1_5_3
= 0x1503,
1147 Version1_6_0
= 0x1600,
1151 Version1_6_1
= 0x1601,
1155 Version1_6_2
= 0x1602,
1159 Version1_6_3
= 0x1603,
1163 Version1_7_0
= 0x1700,
1167 Version1_7_1
= 0x1701,
1171 Version1_7_2
= 0x1702,
1175 Version1_8_0
= 0x1800,
1179 Version1_8_1
= 0x1801,
1183 Version1_8_2
= 0x1802,
1187 Version1_9_0
= 0x1900,
1191 Version1_99_0
= 0x1990,
1195 Version2_0_0
= 0x2000,
1199 Version2_0_1
= 0x2001,
1203 Version2_0_2
= 0x2002,
1207 Version2_0_3
= 0x2003,
1211 Version2_0_4
= 0x2004,
1215 Version2_0_5
= 0x2005,
1219 Version2_1_0
= 0x2100,
1223 Version2_1_1
= 0x2101,
1227 Version2_1_2
= 0x2102,
1231 Version2_1_3
= 0x2103,
1235 Version2_1_4
= 0x2104,
1237 /// The current version
1239 CurrentVersion
= 0x2104
1245 public enum class CecServerVersion
1254 Version1_5_0
= 0x1500,
1258 Version1_5_1
= 0x1501,
1262 Version1_5_2
= 0x1502,
1266 Version1_5_3
= 0x1503,
1270 Version1_6_0
= 0x1600,
1274 Version1_6_1
= 0x1601,
1278 Version1_6_2
= 0x1602,
1282 Version1_6_3
= 0x1603,
1286 Version1_7_0
= 0x1700,
1290 Version1_7_1
= 0x1701,
1294 Version1_7_2
= 0x1702,
1298 Version1_8_0
= 0x1800,
1302 Version1_8_1
= 0x1801,
1306 Version1_8_2
= 0x1802,
1310 Version1_9_0
= 0x1900,
1314 Version1_99_0
= 0x1990,
1318 Version2_0_0
= 0x2000,
1322 Version2_0_1
= 0x2001,
1326 Version2_0_2
= 0x2002,
1330 Version2_0_3
= 0x2003,
1334 Version2_0_4
= 0x2004,
1338 Version2_0_5
= 0x2005,
1342 Version2_1_0
= 0x2100,
1346 Version2_1_1
= 0x2101,
1350 Version2_1_2
= 0x2102,
1354 Version2_1_3
= 0x2103,
1358 Version2_1_4
= 0x2104,
1360 /// The current version
1362 CurrentVersion
= 0x2104
1366 /// Type of adapter to which libCEC is connected
1368 public enum class CecAdapterType
1371 /// Unknown adapter type
1375 /// Pulse-Eight USB-CEC adapter
1377 PulseEightExternal
= 0x1,
1379 /// Pulse-Eight CEC daughterboard
1381 PulseEightDaughterboard
= 0x2,
1385 RaspberryPi
= 0x100,
1393 /// Descriptor of a CEC adapter, returned when scanning for adapters that are connected to the system
1395 public ref
class CecAdapter
1399 /// Create a new CEC adapter descriptor
1401 /// <param name="path"> The path descriptor for this CEC adapter</param>
1402 /// <param name="comPort">The COM port of this CEC adapter</param>
1403 CecAdapter(System::String
^ path
, System::String
^ comPort
)
1410 /// The path descriptor for this CEC adapter
1412 property
System::String
^ Path
;
1415 /// The COM port of this CEC adapter
1417 property
System::String
^ ComPort
;
1421 /// A list of CEC device types
1423 public ref
class CecDeviceTypeList
1427 /// Create a new empty list of CEC device types
1429 CecDeviceTypeList(void)
1431 Types
= gcnew array
<CecDeviceType
>(5);
1432 for (unsigned int iPtr
= 0; iPtr
< 5; iPtr
++)
1433 Types
[iPtr
] = CecDeviceType::Reserved
;
1437 /// The array with CecDeviceType instances in this list.
1439 property array
<CecDeviceType
> ^ Types
;
1443 /// A list of logical addresses
1445 public ref
class CecLogicalAddresses
1449 /// Create a new empty list of logical addresses
1451 CecLogicalAddresses(void)
1453 Addresses
= gcnew array
<CecLogicalAddress
>(16);
1458 /// Clears this list
1462 Primary
= CecLogicalAddress::Unknown
;
1463 for (unsigned int iPtr
= 0; iPtr
< 16; iPtr
++)
1464 Addresses
[iPtr
] = CecLogicalAddress::Unknown
;
1468 /// Checks whether a logical address is set in this list.
1470 /// <param name="address">The address to check.</param>
1471 /// <returns>True when set, false otherwise</returns>
1472 bool IsSet(CecLogicalAddress address
)
1474 return Addresses
[(unsigned int)address
] != CecLogicalAddress::Unknown
;
1478 /// Add a logical address to this list (if it's not set already)
1480 /// <param name="address">The address to add.</param>
1481 void Set(CecLogicalAddress address
)
1483 Addresses
[(unsigned int)address
] = address
;
1484 if (Primary
== CecLogicalAddress::Unknown
)
1489 /// The primary (first) address in this list
1491 property CecLogicalAddress Primary
;
1494 /// The list of addresses
1496 property array
<CecLogicalAddress
> ^ Addresses
;
1501 /// Byte array used for CEC command parameters
1503 public ref
class CecDatapacket
1507 /// Create a new byte array with maximum size 100
1511 Data
= gcnew array
<uint8_t>(100);
1516 /// Adds a byte to this byte array
1518 /// <param name="data">The byte to add.</param>
1519 void PushBack(uint8_t data
)
1531 property array
<uint8_t> ^ Data
;
1534 /// Current data size
1536 property
uint8_t Size
;
1540 /// A CEC command that is received or transmitted over the CEC bus
1542 public ref
class CecCommand
1546 /// Create a new CEC command instance
1548 /// <param name="initiator">The initiator of the command</param>
1549 /// <param name="destination">The receiver of the command</param>
1550 /// <param name="ack">True when the ack bit is set, false otherwise</param>
1551 /// <param name="eom">True when the eom bit is set, false otherwise</param>
1552 /// <param name="opcode">The CEC opcode of this command</param>
1553 /// <param name="transmitTimeout">The timeout to use when transmitting a command</param>
1554 CecCommand(CecLogicalAddress initiator
, CecLogicalAddress destination
, bool ack
, bool eom
, CecOpcode opcode
, int32_t transmitTimeout
)
1556 Initiator
= initiator
;
1557 Destination
= destination
;
1562 TransmitTimeout
= transmitTimeout
;
1563 Parameters
= gcnew CecDatapacket
;
1568 /// Create a new empty CEC command instance
1572 Initiator
= CecLogicalAddress::Unknown
;
1573 Destination
= CecLogicalAddress::Unknown
;
1576 Opcode
= CecOpcode::None
;
1578 TransmitTimeout
= 0;
1579 Parameters
= gcnew CecDatapacket
;
1584 /// Pushes a byte of data to this CEC command
1586 /// <param name="data">The byte to add</param>
1587 void PushBack(uint8_t data
)
1589 if (Initiator
== CecLogicalAddress::Unknown
&& Destination
== CecLogicalAddress::Unknown
)
1591 Initiator
= (CecLogicalAddress
) (data
>> 4);
1592 Destination
= (CecLogicalAddress
) (data
& 0xF);
1594 else if (!OpcodeSet
)
1597 Opcode
= (CecOpcode
)data
;
1601 Parameters
->PushBack(data
);
1606 /// True when this command is empty, false otherwise.
1608 property
bool Empty
;
1610 /// The initiator of the command
1612 property CecLogicalAddress Initiator
;
1614 /// The destination of the command
1616 property CecLogicalAddress Destination
;
1618 /// True when the ack bit is set, false otherwise
1622 /// True when the eom bit is set, false otherwise
1626 /// The CEC opcode of the command
1628 property CecOpcode Opcode
;
1630 /// The parameters of this command
1632 property CecDatapacket
^ Parameters
;
1634 /// True when an opcode is set, false otherwise (poll message)
1636 property
bool OpcodeSet
;
1638 /// The timeout to use when transmitting a command
1640 property
int32_t TransmitTimeout
;
1644 /// A key press that was received
1646 public ref
class CecKeypress
1650 /// Create a new key press instance
1652 /// <param name="keycode">The key code of this key press</param>
1653 /// <param name="duration">The duration of this key press in milliseconds</param>
1654 CecKeypress(CecUserControlCode keycode
, unsigned int duration
)
1657 Duration
= duration
;
1662 /// Create a new empty key press instance
1666 Keycode
= CecUserControlCode::Unknown
;
1672 /// True when empty, false otherwise
1674 property
bool Empty
;
1676 /// The key code of this key press
1678 property CecUserControlCode Keycode
;
1680 /// The duration of this key press in milliseconds
1682 property
unsigned int Duration
;
1686 /// A log message that libCEC generated
1688 public ref
class CecLogMessage
1692 /// Create a new log message
1694 /// <param name="message">The actual message</param>
1695 /// <param name="level">The log level, so the application can choose what type information to display</param>
1696 /// <param name="time">The timestamp of this message, in milliseconds after connecting</param>
1697 CecLogMessage(System::String
^ message
, CecLogLevel level
, int64_t time
)
1706 /// Create a new empty log message
1711 Level
= CecLogLevel::None
;
1717 /// True when empty, false otherwise.
1719 property
bool Empty
;
1721 /// The actual message
1723 property
System::String
^Message
;
1725 /// The log level, so the application can choose what type information to display
1727 property CecLogLevel Level
;
1729 /// The timestamp of this message, in milliseconds after connecting
1731 property
int64_t Time
;
1734 ref
class CecCallbackMethods
; //forward declaration
1737 /// The configuration that libCEC uses.
1739 public ref
class LibCECConfiguration
1743 /// Create a new configuration instance with default settings.
1745 LibCECConfiguration(void)
1748 DeviceTypes
= gcnew
CecDeviceTypeList();
1749 AutodetectAddress
= true;
1750 PhysicalAddress
= CEC_DEFAULT_PHYSICAL_ADDRESS
;
1751 BaseDevice
= (CecLogicalAddress
)CEC_DEFAULT_BASE_DEVICE
;
1752 HDMIPort
= CEC_DEFAULT_HDMI_PORT
;
1753 ClientVersion
= CecClientVersion::CurrentVersion
;
1754 ServerVersion
= CecServerVersion::CurrentVersion
;
1755 TvVendor
= CecVendorId::Unknown
;
1757 GetSettingsFromROM
= false;
1758 UseTVMenuLanguage
= CEC_DEFAULT_SETTING_USE_TV_MENU_LANGUAGE
== 1;
1759 ActivateSource
= CEC_DEFAULT_SETTING_ACTIVATE_SOURCE
== 1;
1761 WakeDevices
= gcnew
CecLogicalAddresses();
1762 if (CEC_DEFAULT_SETTING_ACTIVATE_SOURCE
== 1)
1763 WakeDevices
->Set(CecLogicalAddress::Tv
);
1765 PowerOffDevices
= gcnew
CecLogicalAddresses();
1766 if (CEC_DEFAULT_SETTING_POWER_OFF_SHUTDOWN
== 1)
1767 PowerOffDevices
->Set(CecLogicalAddress::Broadcast
);
1769 PowerOffScreensaver
= CEC_DEFAULT_SETTING_POWER_OFF_SCREENSAVER
== 1;
1770 PowerOffOnStandby
= CEC_DEFAULT_SETTING_POWER_OFF_ON_STANDBY
== 1;
1772 SendInactiveSource
= CEC_DEFAULT_SETTING_SEND_INACTIVE_SOURCE
== 1;
1773 LogicalAddresses
= gcnew
CecLogicalAddresses();
1774 FirmwareVersion
= 1;
1775 PowerOffDevicesOnStandby
= CEC_DEFAULT_SETTING_POWER_OFF_DEVICES_STANDBY
== 1;
1776 ShutdownOnStandby
= CEC_DEFAULT_SETTING_SHUTDOWN_ON_STANDBY
== 1;
1777 DeviceLanguage
= "";
1778 FirmwareBuildDate
= gcnew
System::DateTime(1970,1,1,0,0,0,0);
1779 CECVersion
= (CecVersion
)CEC_DEFAULT_SETTING_CEC_VERSION
;
1780 AdapterType
= CecAdapterType::Unknown
;
1784 /// Change the callback method pointers in this configuration instance.
1786 /// <param name="callbacks">The new callbacks</param>
1787 void SetCallbacks(CecCallbackMethods
^callbacks
)
1789 Callbacks
= callbacks
;
1793 /// Update this configuration with data received from libCEC
1795 /// <param name="config">The configuration that was received from libCEC</param>
1796 void Update(const CEC::libcec_configuration
&config
)
1798 DeviceName
= gcnew
System::String(config
.strDeviceName
);
1800 for (unsigned int iPtr
= 0; iPtr
< 5; iPtr
++)
1801 DeviceTypes
->Types
[iPtr
] = (CecDeviceType
)config
.deviceTypes
.types
[iPtr
];
1803 AutodetectAddress
= config
.bAutodetectAddress
== 1;
1804 PhysicalAddress
= config
.iPhysicalAddress
;
1805 BaseDevice
= (CecLogicalAddress
)config
.baseDevice
;
1806 HDMIPort
= config
.iHDMIPort
;
1807 ClientVersion
= (CecClientVersion
)config
.clientVersion
;
1808 ServerVersion
= (CecServerVersion
)config
.serverVersion
;
1809 TvVendor
= (CecVendorId
)config
.tvVendor
;
1811 // player specific settings
1812 GetSettingsFromROM
= config
.bGetSettingsFromROM
== 1;
1813 UseTVMenuLanguage
= config
.bUseTVMenuLanguage
== 1;
1814 ActivateSource
= config
.bActivateSource
== 1;
1816 WakeDevices
->Clear();
1817 for (uint8_t iPtr
= 0; iPtr
<= 16; iPtr
++)
1818 if (config
.wakeDevices
[iPtr
])
1819 WakeDevices
->Set((CecLogicalAddress
)iPtr
);
1821 PowerOffDevices
->Clear();
1822 for (uint8_t iPtr
= 0; iPtr
<= 16; iPtr
++)
1823 if (config
.powerOffDevices
[iPtr
])
1824 PowerOffDevices
->Set((CecLogicalAddress
)iPtr
);
1826 PowerOffScreensaver
= config
.bPowerOffScreensaver
== 1;
1827 PowerOffOnStandby
= config
.bPowerOffOnStandby
== 1;
1829 if (ServerVersion
>= CecServerVersion::Version1_5_1
)
1830 SendInactiveSource
= config
.bSendInactiveSource
== 1;
1832 if (ServerVersion
>= CecServerVersion::Version1_5_3
)
1834 LogicalAddresses
->Clear();
1835 for (uint8_t iPtr
= 0; iPtr
<= 16; iPtr
++)
1836 if (config
.logicalAddresses
[iPtr
])
1837 LogicalAddresses
->Set((CecLogicalAddress
)iPtr
);
1840 if (ServerVersion
>= CecServerVersion::Version1_6_0
)
1842 FirmwareVersion
= config
.iFirmwareVersion
;
1843 PowerOffDevicesOnStandby
= config
.bPowerOffDevicesOnStandby
== 1;
1844 ShutdownOnStandby
= config
.bShutdownOnStandby
== 1;
1847 if (ServerVersion
>= CecServerVersion::Version1_6_2
)
1849 DeviceLanguage
= gcnew
System::String(config
.strDeviceLanguage
);
1850 FirmwareBuildDate
= gcnew
System::DateTime(1970,1,1,0,0,0,0);
1851 FirmwareBuildDate
= FirmwareBuildDate
->AddSeconds(config
.iFirmwareBuildDate
);
1854 if (ServerVersion
>= CecServerVersion::Version1_6_3
)
1855 MonitorOnlyClient
= config
.bMonitorOnly
== 1;
1857 if (ServerVersion
>= CecServerVersion::Version1_8_0
)
1858 CECVersion
= (CecVersion
)config
.cecVersion
;
1860 if (ServerVersion
>= CecServerVersion::Version1_8_2
)
1861 AdapterType
= (CecAdapterType
)config
.adapterType
;
1863 if (ServerVersion
>= CecServerVersion::Version2_1_0
)
1864 PowerOnScreensaver
= config
.bPowerOnScreensaver
== 1;
1868 /// The device name to use on the CEC bus
1870 property
System::String
^ DeviceName
;
1873 /// The device type(s) to use on the CEC bus for libCEC
1875 property CecDeviceTypeList
^ DeviceTypes
;
1878 /// (read only) set to true by libCEC when the physical address was autodetected
1880 property
bool AutodetectAddress
;
1883 /// The physical address of the CEC adapter
1885 property
uint16_t PhysicalAddress
;
1888 /// The logical address of the device to which the adapter is connected. Only used when PhysicalAddress = 0 or when the adapter doesn't support autodetection
1890 property CecLogicalAddress BaseDevice
;
1893 /// The HDMI port to which the adapter is connected. Only used when iPhysicalAddress = 0 or when the adapter doesn't support autodetection
1895 property
uint8_t HDMIPort
;
1898 /// The client API version to use
1900 property CecClientVersion ClientVersion
;
1903 /// The version of libCEC
1905 property CecServerVersion ServerVersion
;
1908 /// Override the vendor ID of the TV. Leave this untouched to autodetect
1910 property CecVendorId TvVendor
;
1913 /// True to read the settings from the EEPROM, which possibly override the settings passed here
1915 property
bool GetSettingsFromROM
;
1918 /// Use the language setting of the TV in the client application. Must be implemented by the client application.
1919 /// 3 character ISO 639-2 country code. see http://http://www.loc.gov/standards/iso639-2/
1921 property
bool UseTVMenuLanguage
;
1924 /// Make libCEC the active source when starting the client application
1926 property
bool ActivateSource
;
1929 /// List of devices to wake when initialising libCEC or when calling PowerOnDevices() without any parameter.
1931 property CecLogicalAddresses
^WakeDevices
;
1934 /// List of devices to power off when calling StandbyDevices() without any parameter.
1936 property CecLogicalAddresses
^PowerOffDevices
;
1939 /// Send standby commands when the client application activates the screensaver. Must be implemented by the client application.
1941 property
bool PowerOffScreensaver
;
1944 /// Power off the PC when the TV powers off. Must be implemented by the client application.
1946 property
bool PowerOffOnStandby
;
1949 /// Send an inactive source message when exiting the client application.
1951 property
bool SendInactiveSource
;
1954 /// The list of logical addresses that libCEC is using
1956 property CecLogicalAddresses
^LogicalAddresses
;
1959 /// The firmware version of the adapter to which libCEC is connected
1961 property
uint16_t FirmwareVersion
;
1964 /// Send standby commands when the client application activates standby mode (S3). Must be implemented by the client application.
1966 property
bool PowerOffDevicesOnStandby
;
1969 /// Shutdown this PC when the TV is switched off. only used when PowerOffOnStandby = false
1971 property
bool ShutdownOnStandby
;
1974 /// True to start a monitor-only client, false to start a standard client.
1976 property
bool MonitorOnlyClient
;
1979 /// The language code of the menu language that libCEC reports to other devices.
1980 /// 3 character ISO 639-2 country code. see http://http://www.loc.gov/standards/iso639-2/
1982 property
System::String
^ DeviceLanguage
;
1985 /// The callback methods to use.
1987 property CecCallbackMethods
^ Callbacks
;
1990 /// The build date of the firmware.
1992 property
System::DateTime
^ FirmwareBuildDate
;
1995 /// The CEC version that libCEC uses.
1997 property CecVersion CECVersion
;
2000 /// The type of adapter that libCEC is connected to.
2002 property CecAdapterType AdapterType
;
2005 /// True to power on when quitting the screensaver.
2007 property
bool PowerOnScreensaver
;
2010 // the callback methods are called by unmanaged code, so we need some delegates for this
2012 // unmanaged callback methods
2013 typedef int (__stdcall
*LOGCB
) (const CEC::cec_log_message
&message
);
2014 typedef int (__stdcall
*KEYCB
) (const CEC::cec_keypress
&key
);
2015 typedef int (__stdcall
*COMMANDCB
)(const CEC::cec_command
&command
);
2016 typedef int (__stdcall
*CONFIGCB
) (const CEC::libcec_configuration
&config
);
2017 typedef int (__stdcall
*ALERTCB
) (const CEC::libcec_alert
, const CEC::libcec_parameter
&data
);
2018 typedef int (__stdcall
*MENUCB
) (const CEC::cec_menu_state newVal
);
2019 typedef void (__stdcall
*ACTICB
) (const CEC::cec_logical_address logicalAddress
, const uint8_t bActivated
);
2022 /// libCEC callback methods. Unmanaged code.
2027 /// Log message callback
2031 /// Key press/release callback
2035 /// Raw CEC data callback
2037 COMMANDCB commandCB
;
2039 /// Updated configuration callback
2043 /// Alert message callback
2047 /// Menu status change callback
2051 /// Source (de)activated callback
2053 ACTICB sourceActivatedCB
;
2054 } UnmanagedCecCallbacks
;
2056 static PLATFORM::CMutex g_callbackMutex
;
2057 static std::vector
<UnmanagedCecCallbacks
> g_unmanagedCallbacks
;
2058 static CEC::ICECCallbacks g_cecCallbacks
;
2061 /// Called by libCEC to send back a log message to the application
2063 /// <param name="cbParam">Pointer to the callback struct</param>
2064 /// <param name="message">The log message</param>
2065 /// <return>1 when handled, 0 otherwise</return>
2066 int CecLogMessageCB(void *cbParam
, const CEC::cec_log_message message
)
2070 size_t iPtr
= (size_t)cbParam
;
2071 PLATFORM::CLockObject
lock(g_callbackMutex
);
2072 if (iPtr
>= 0 && iPtr
< g_unmanagedCallbacks
.size())
2073 return g_unmanagedCallbacks
[iPtr
].logCB(message
);
2079 /// Called by libCEC to send back a key press or release to the application
2081 /// <param name="cbParam">Pointer to the callback struct</param>
2082 /// <param name="key">The key press command that libCEC received</param>
2083 /// <return>1 when handled, 0 otherwise</return>
2084 int CecKeyPressCB(void *cbParam
, const CEC::cec_keypress key
)
2088 size_t iPtr
= (size_t)cbParam
;
2089 PLATFORM::CLockObject
lock(g_callbackMutex
);
2090 if (iPtr
>= 0 && iPtr
< g_unmanagedCallbacks
.size())
2091 return g_unmanagedCallbacks
[iPtr
].keyCB(key
);
2097 /// Called by libCEC to send back raw CEC data to the application
2099 /// <param name="cbParam">Pointer to the callback struct</param>
2100 /// <param name="command">The raw CEC data</param>
2101 /// <return>1 when handled, 0 otherwise</return>
2102 int CecCommandCB(void *cbParam
, const CEC::cec_command command
)
2106 size_t iPtr
= (size_t)cbParam
;
2107 PLATFORM::CLockObject
lock(g_callbackMutex
);
2108 if (iPtr
>= 0 && iPtr
< g_unmanagedCallbacks
.size())
2109 return g_unmanagedCallbacks
[iPtr
].commandCB(command
);
2115 /// Called by libCEC to send back an updated configuration to the application
2117 /// <param name="cbParam">Pointer to the callback struct</param>
2118 /// <param name="config">The new configuration</param>
2119 /// <return>1 when handled, 0 otherwise</return>
2120 int CecConfigCB(void *cbParam
, const CEC::libcec_configuration config
)
2124 size_t iPtr
= (size_t)cbParam
;
2125 PLATFORM::CLockObject
lock(g_callbackMutex
);
2126 if (iPtr
>= 0 && iPtr
< g_unmanagedCallbacks
.size())
2127 return g_unmanagedCallbacks
[iPtr
].configCB(config
);
2133 /// Called by libCEC to send back an alert message to the application
2135 /// <param name="cbParam">Pointer to the callback struct</param>
2136 /// <param name="data">The alert message</param>
2137 /// <return>1 when handled, 0 otherwise</return>
2138 int CecAlertCB(void *cbParam
, const CEC::libcec_alert alert
, const CEC::libcec_parameter data
)
2142 size_t iPtr
= (size_t)cbParam
;
2143 PLATFORM::CLockObject
lock(g_callbackMutex
);
2144 if (iPtr
>= 0 && iPtr
< g_unmanagedCallbacks
.size())
2145 return g_unmanagedCallbacks
[iPtr
].alertCB(alert
, data
);
2151 /// Called by libCEC to send back a menu state change to the application
2153 /// <param name="cbParam">Pointer to the callback struct</param>
2154 /// <param name="newVal">The new menu state</param>
2155 /// <return>1 when handled, 0 otherwise</return>
2156 int CecMenuCB(void *cbParam
, const CEC::cec_menu_state newVal
)
2160 size_t iPtr
= (size_t)cbParam
;
2161 PLATFORM::CLockObject
lock(g_callbackMutex
);
2162 if (iPtr
>= 0 && iPtr
< g_unmanagedCallbacks
.size())
2163 return g_unmanagedCallbacks
[iPtr
].menuCB(newVal
);
2169 /// Called by libCEC to notify the application that the source that is handled by libCEC was (de)activated
2171 /// <param name="cbParam">Pointer to the callback struct</param>
2172 /// <param name="logicalAddress">The logical address that was (de)activated</param>
2173 /// <param name="activated">True when activated, false when deactivated</param>
2174 void CecSourceActivatedCB(void *cbParam
, const CEC::cec_logical_address logicalAddress
, const uint8_t activated
)
2178 size_t iPtr
= (size_t)cbParam
;
2179 PLATFORM::CLockObject
lock(g_callbackMutex
);
2180 if (iPtr
>= 0 && iPtr
< g_unmanagedCallbacks
.size())
2181 g_unmanagedCallbacks
[iPtr
].sourceActivatedCB(logicalAddress
, activated
);
2187 /// Delegate method for the CecLogMessageCB callback in CecCallbackMethods
2189 public delegate
int CecLogMessageManagedDelegate(const CEC::cec_log_message
&);
2191 /// Delegate method for the CecKeyPressCB callback in CecCallbackMethods
2193 public delegate
int CecKeyPressManagedDelegate(const CEC::cec_keypress
&);
2195 /// Delegate method for the CecCommandCB callback in CecCallbackMethods
2197 public delegate
int CecCommandManagedDelegate(const CEC::cec_command
&);
2199 /// Delegate method for the CecConfigCB callback in CecCallbackMethods
2201 public delegate
int CecConfigManagedDelegate(const CEC::libcec_configuration
&);
2203 /// Delegate method for the CecAlertCB callback in CecCallbackMethods
2205 public delegate
int CecAlertManagedDelegate(const CEC::libcec_alert
, const CEC::libcec_parameter
&);
2207 /// Delegate method for the CecMenuCB callback in CecCallbackMethods
2209 public delegate
int CecMenuManagedDelegate(const CEC::cec_menu_state
);
2211 /// Delegate method for the CecSourceActivatedCB callback in CecCallbackMethods
2213 public delegate
void CecSourceActivatedManagedDelegate(const CEC::cec_logical_address
, const uint8_t);
2216 /// Assign the callback methods in the g_cecCallbacks struct
2218 void AssignCallbacks()
2220 g_cecCallbacks
.CBCecLogMessage
= CecLogMessageCB
;
2221 g_cecCallbacks
.CBCecKeyPress
= CecKeyPressCB
;
2222 g_cecCallbacks
.CBCecCommand
= CecCommandCB
;
2223 g_cecCallbacks
.CBCecConfigurationChanged
= CecConfigCB
;
2224 g_cecCallbacks
.CBCecAlert
= CecAlertCB
;
2225 g_cecCallbacks
.CBCecMenuStateChanged
= CecMenuCB
;
2226 g_cecCallbacks
.CBCecSourceActivated
= CecSourceActivatedCB
;
2230 /// The callback methods that libCEC uses
2232 public ref
class CecCallbackMethods
2235 CecCallbackMethods(void)
2237 m_iCallbackPtr
= -1;
2239 m_bHasCallbacks
= false;
2240 m_bDelegatesCreated
= false;
2243 ~CecCallbackMethods(void)
2249 /// Pointer to the callbacks struct entry
2251 size_t GetCallbackPtr(void)
2253 PLATFORM::CLockObject
lock(g_callbackMutex
);
2254 return m_iCallbackPtr
;
2258 !CecCallbackMethods(void)
2265 /// Disable callback methods
2267 virtual void DisableCallbacks(void)
2273 /// Enable callback methods
2275 /// <param name="callbacks">Callback methods to activate</param>
2276 /// <return>true when handled, false otherwise</return>
2277 virtual bool EnableCallbacks(CecCallbackMethods
^ callbacks
)
2280 if (!m_bHasCallbacks
)
2282 m_bHasCallbacks
= true;
2283 m_callbacks
= callbacks
;
2291 /// Called by libCEC to send back a log message to the application.
2292 /// Override in the application to handle this callback.
2294 /// <param name="message">The log message</param>
2295 /// <return>1 when handled, 0 otherwise</return>
2296 virtual int ReceiveLogMessage(CecLogMessage
^ message
)
2302 /// Called by libCEC to send back a key press or release to the application.
2303 /// Override in the application to handle this callback.
2305 /// <param name="key">The key press command that libCEC received</param>
2306 /// <return>1 when handled, 0 otherwise</return>
2307 virtual int ReceiveKeypress(CecKeypress
^ key
)
2313 /// Called by libCEC to send back raw CEC data to the application.
2314 /// Override in the application to handle this callback.
2316 /// <param name="command">The raw CEC data</param>
2317 /// <return>1 when handled, 0 otherwise</return>
2318 virtual int ReceiveCommand(CecCommand
^ command
)
2324 /// Called by libCEC to send back an updated configuration to the application.
2325 /// Override in the application to handle this callback.
2327 /// <param name="config">The new configuration</param>
2328 /// <return>1 when handled, 0 otherwise</return>
2329 virtual int ConfigurationChanged(LibCECConfiguration
^ config
)
2335 /// Called by libCEC to send back an alert message to the application.
2336 /// Override in the application to handle this callback.
2338 /// <param name="data">The alert message</param>
2339 /// <return>1 when handled, 0 otherwise</return>
2340 virtual int ReceiveAlert(CecAlert alert
, CecParameter
^ data
)
2346 /// Called by libCEC to send back a menu state change to the application.
2347 /// Override in the application to handle this callback.
2349 /// <param name="newVal">The new menu state</param>
2350 /// <return>1 when handled, 0 otherwise</return>
2351 virtual int ReceiveMenuStateChange(CecMenuState newVal
)
2357 /// Called by libCEC to notify the application that the source that is handled by libCEC was (de)activated.
2358 /// Override in the application to handle this callback.
2360 /// <param name="logicalAddress">The logical address that was (de)activated</param>
2361 /// <param name="activated">True when activated, false when deactivated</param>
2362 virtual void SourceActivated(CecLogicalAddress logicalAddress
, bool activated
)
2367 // managed callback methods
2368 int CecLogMessageManaged(const CEC::cec_log_message
&message
)
2371 if (m_bHasCallbacks
)
2372 iReturn
= m_callbacks
->ReceiveLogMessage(gcnew
CecLogMessage(gcnew
System::String(message
.message
), (CecLogLevel
)message
.level
, message
.time
));
2376 int CecKeyPressManaged(const CEC::cec_keypress
&key
)
2379 if (m_bHasCallbacks
)
2380 iReturn
= m_callbacks
->ReceiveKeypress(gcnew
CecKeypress((CecUserControlCode
)key
.keycode
, key
.duration
));
2384 int CecCommandManaged(const CEC::cec_command
&command
)
2387 if (m_bHasCallbacks
)
2389 CecCommand
^ newCommand
= gcnew
CecCommand((CecLogicalAddress
)command
.initiator
, (CecLogicalAddress
)command
.destination
, command
.ack
== 1 ? true : false, command
.eom
== 1 ? true : false, (CecOpcode
)command
.opcode
, command
.transmit_timeout
);
2390 for (uint8_t iPtr
= 0; iPtr
< command
.parameters
.size
; iPtr
++)
2391 newCommand
->Parameters
->PushBack(command
.parameters
[iPtr
]);
2392 iReturn
= m_callbacks
->ReceiveCommand(newCommand
);
2397 int CecConfigManaged(const CEC::libcec_configuration
&config
)
2400 if (m_bHasCallbacks
)
2402 LibCECConfiguration
^netConfig
= gcnew
LibCECConfiguration();
2403 netConfig
->Update(config
);
2404 iReturn
= m_callbacks
->ConfigurationChanged(netConfig
);
2409 int CecAlertManaged(const CEC::libcec_alert alert
, const CEC::libcec_parameter
&data
)
2412 if (m_bHasCallbacks
)
2414 CecParameterType newType
= (CecParameterType
)data
.paramType
;
2415 if (newType
== CecParameterType::ParameterTypeString
)
2417 System::String
^ newData
= gcnew
System::String(data
.paramData
? (const char *)data
.paramData
: "", 0, 128);
2418 CecParameter
^ newParam
= gcnew
CecParameter(newType
, newData
);
2419 iReturn
= m_callbacks
->ReceiveAlert((CecAlert
)alert
, newParam
);
2425 int CecMenuManaged(const CEC::cec_menu_state newVal
)
2428 if (m_bHasCallbacks
)
2430 iReturn
= m_callbacks
->ReceiveMenuStateChange((CecMenuState
)newVal
);
2435 void CecSourceActivatedManaged(const CEC::cec_logical_address logicalAddress
, const uint8_t bActivated
)
2437 if (m_bHasCallbacks
)
2438 m_callbacks
->SourceActivated((CecLogicalAddress
)logicalAddress
, bActivated
== 1);
2441 void DestroyDelegates()
2443 m_bHasCallbacks
= false;
2444 if (m_bDelegatesCreated
)
2446 m_bDelegatesCreated
= false;
2447 m_logMessageGCHandle
.Free();
2448 m_keypressGCHandle
.Free();
2449 m_commandGCHandle
.Free();
2450 m_alertGCHandle
.Free();
2451 m_menuGCHandle
.Free();
2452 m_sourceActivatedGCHandle
.Free();
2456 void CreateDelegates()
2460 if (!m_bDelegatesCreated
)
2462 msclr::interop::marshal_context
^ context
= gcnew
msclr::interop::marshal_context();
2464 // create the delegate method for the log message callback
2465 m_logMessageDelegate
= gcnew
CecLogMessageManagedDelegate(this, &CecCallbackMethods::CecLogMessageManaged
);
2466 m_logMessageGCHandle
= System::Runtime::InteropServices::GCHandle::Alloc(m_logMessageDelegate
);
2467 m_logMessageCallback
= static_cast<LOGCB
>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_logMessageDelegate
).ToPointer());
2469 // create the delegate method for the keypress callback
2470 m_keypressDelegate
= gcnew
CecKeyPressManagedDelegate(this, &CecCallbackMethods::CecKeyPressManaged
);
2471 m_keypressGCHandle
= System::Runtime::InteropServices::GCHandle::Alloc(m_keypressDelegate
);
2472 m_keypressCallback
= static_cast<KEYCB
>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_keypressDelegate
).ToPointer());
2474 // create the delegate method for the command callback
2475 m_commandDelegate
= gcnew
CecCommandManagedDelegate(this, &CecCallbackMethods::CecCommandManaged
);
2476 m_commandGCHandle
= System::Runtime::InteropServices::GCHandle::Alloc(m_commandDelegate
);
2477 m_commandCallback
= static_cast<COMMANDCB
>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_commandDelegate
).ToPointer());
2479 // create the delegate method for the configuration change callback
2480 m_configDelegate
= gcnew
CecConfigManagedDelegate(this, &CecCallbackMethods::CecConfigManaged
);
2481 m_configGCHandle
= System::Runtime::InteropServices::GCHandle::Alloc(m_configDelegate
);
2482 m_configCallback
= static_cast<CONFIGCB
>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_configDelegate
).ToPointer());
2484 // create the delegate method for the alert callback
2485 m_alertDelegate
= gcnew
CecAlertManagedDelegate(this, &CecCallbackMethods::CecAlertManaged
);
2486 m_alertGCHandle
= System::Runtime::InteropServices::GCHandle::Alloc(m_alertDelegate
);
2487 m_alertCallback
= static_cast<ALERTCB
>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_alertDelegate
).ToPointer());
2489 // create the delegate method for the menu callback
2490 m_menuDelegate
= gcnew
CecMenuManagedDelegate(this, &CecCallbackMethods::CecMenuManaged
);
2491 m_menuGCHandle
= System::Runtime::InteropServices::GCHandle::Alloc(m_menuDelegate
);
2492 m_menuCallback
= static_cast<MENUCB
>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_menuDelegate
).ToPointer());
2494 // create the delegate method for the source activated callback
2495 m_sourceActivatedDelegate
= gcnew
CecSourceActivatedManagedDelegate(this, &CecCallbackMethods::CecSourceActivatedManaged
);
2496 m_sourceActivatedGCHandle
= System::Runtime::InteropServices::GCHandle::Alloc(m_sourceActivatedDelegate
);
2497 m_sourceActivatedCallback
= static_cast<ACTICB
>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_sourceActivatedDelegate
).ToPointer());
2501 UnmanagedCecCallbacks unmanagedCallbacks
;
2502 unmanagedCallbacks
.logCB
= m_logMessageCallback
;
2503 unmanagedCallbacks
.keyCB
= m_keypressCallback
;
2504 unmanagedCallbacks
.commandCB
= m_commandCallback
;
2505 unmanagedCallbacks
.configCB
= m_configCallback
;
2506 unmanagedCallbacks
.alertCB
= m_alertCallback
;
2507 unmanagedCallbacks
.menuCB
= m_menuCallback
;
2508 unmanagedCallbacks
.sourceActivatedCB
= m_sourceActivatedCallback
;
2510 PLATFORM::CLockObject
lock(g_callbackMutex
);
2511 g_unmanagedCallbacks
.push_back(unmanagedCallbacks
);
2512 m_iCallbackPtr
= g_unmanagedCallbacks
.size() - 1;
2513 m_bDelegatesCreated
= true;
2517 CecLogMessageManagedDelegate
^ m_logMessageDelegate
;
2518 static System::Runtime::InteropServices::GCHandle m_logMessageGCHandle
;
2519 LOGCB m_logMessageCallback
;
2521 CecKeyPressManagedDelegate
^ m_keypressDelegate
;
2522 static System::Runtime::InteropServices::GCHandle m_keypressGCHandle
;
2523 KEYCB m_keypressCallback
;
2525 CecCommandManagedDelegate
^ m_commandDelegate
;
2526 static System::Runtime::InteropServices::GCHandle m_commandGCHandle
;
2527 COMMANDCB m_commandCallback
;
2529 CecConfigManagedDelegate
^ m_configDelegate
;
2530 static System::Runtime::InteropServices::GCHandle m_configGCHandle
;
2531 CONFIGCB m_configCallback
;
2533 CecAlertManagedDelegate
^ m_alertDelegate
;
2534 static System::Runtime::InteropServices::GCHandle m_alertGCHandle
;
2535 ALERTCB m_alertCallback
;
2537 CecMenuManagedDelegate
^ m_menuDelegate
;
2538 static System::Runtime::InteropServices::GCHandle m_menuGCHandle
;
2539 MENUCB m_menuCallback
;
2541 CecSourceActivatedManagedDelegate
^ m_sourceActivatedDelegate
;
2542 static System::Runtime::InteropServices::GCHandle m_sourceActivatedGCHandle
;
2543 ACTICB m_sourceActivatedCallback
;
2545 CecCallbackMethods
^ m_callbacks
;
2546 bool m_bHasCallbacks
;
2547 bool m_bDelegatesCreated
;
2548 size_t m_iCallbackPtr
;