3 * This file is part of the libCEC(R) library.
5 * libCEC(R) is Copyright (C) 2011-2012 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/
207 /// The type of parameter that is sent with the CecAlert callback
209 public enum class CecParameterType
212 /// The parameter is a string
214 ParameterTypeString
= 1
218 /// A parameter for the CecAlert callback
220 public ref
class CecParameter
224 /// Create a new parameter
226 /// <param name="type">The type of this parameter.</param>
227 /// <param name="data">The value of this parameter.</param>
228 CecParameter(CecParameterType type
, System::String
^ data
)
235 /// The type of this parameter
237 property CecParameterType Type
;
239 /// The value of this parameter
241 property
System::String
^ Data
;
245 /// The power status of a CEC device
247 public enum class CecPowerStatus
258 /// In transition from standby to on
260 InTransitionStandbyToOn
= 0x02,
262 /// In transition from on to standby
264 InTransitionOnToStandby
= 0x03,
272 /// The CEC version of a CEC device
274 public enum class CecVersion
303 /// Parameter for OSD string display, that controls how to display the string
305 public enum class CecDisplayControl
308 /// Display for the default time
310 DisplayForDefaultTime
= 0x00,
312 /// Display until it is cleared by ClearPreviousMessage
314 DisplayUntilCleared
= 0x40,
316 /// Clear message displayed by DisplayUntilCleared
318 ClearPreviousMessage
= 0x80,
320 /// Reserved / do not use
322 ReservedForFutureUse
= 0xC0
326 /// The menu state of a CEC device
328 public enum class CecMenuState
341 /// Deck control mode for playback and recording devices
343 public enum class CecDeckControlMode
346 /// Skip forward / wind
350 /// Skip reverse / rewind
352 SkipReverseRewind
= 2,
364 /// Deck status for playback and recording devices
366 public enum class CecDeckInfo
381 /// Showing still frame
389 /// Playing slow reverse
401 /// No media detected
405 /// Stop / not playing
409 /// Skip forward / wind
411 SkipForwardWind
= 0x1B,
413 /// Skip reverse / rewind
415 SkipReverseRewind
= 0x1C,
417 /// Index search forward
419 IndexSearchForward
= 0x1D,
421 /// Index search reverse
423 IndexSearchReverse
= 0x1E,
425 /// Other / unknown status
431 /// User control code, the key code when the user presses or releases a button on the remote.
432 /// Used by SendKeypress() and the CecKey callback.
434 public enum class CecUserControlCode
457 /// Direction right + up
461 /// Direction right + down
465 /// Direction left + up
469 /// Direction left + down
559 PreviousChannel
= 0x32,
561 /// Select sound track
569 /// Display information
571 DisplayInformation
= 0x35,
585 /// Toggle powered on / standby
649 /// Toggle sub picture
653 /// Toggle video on demand
655 VideoOnDemand
= 0x52,
657 /// Toggle electronic program guide (EPG)
659 ElectronicProgramGuide
= 0x53,
661 /// Toggle timer programming
663 TimerProgramming
= 0x54,
665 /// Set initial configuration
667 InitialConfiguration
= 0x55,
669 /// Start playback function
673 /// Pause playback function
675 PausePlayFunction
= 0x61,
677 /// Toggle recording function
679 RecordFunction
= 0x62,
681 /// Pause recording function
683 PauseRecordFunction
= 0x63,
685 /// Stop playback function
689 /// Mute audio function
693 /// Restore volume function
695 RestoreVolumeFunction
= 0x66,
701 /// Select media function
703 SelectMediaFunction
= 0x68,
705 /// Select AV input function
707 SelectAVInputFunction
= 0x69,
709 /// Select audio input function
711 SelectAudioInputFunction
= 0x6A,
713 /// Toggle powered on / standby function
715 PowerToggleFunction
= 0x6B,
717 /// Power off function
719 PowerOffFunction
= 0x6C,
721 /// Power on function
723 PowerOnFunction
= 0x6D,
733 /// F3 / green button
737 /// F4 / yellow button
749 /// Max. valid key code for standard buttons
753 /// Extra return button on Samsung remotes
755 SamsungReturn
= 0x91,
757 /// Unknown / invalid key code
763 /// Vendor IDs for CEC devices
765 public enum class CecVendorId
769 Panasonic
= 0x008045,
787 /// Audio status of audio system / AVR devices
789 public enum class CecAudioStatus
794 MuteStatusMask
= 0x80,
796 /// Not muted, volume status mask
798 VolumeStatusMask
= 0x7F,
810 VolumeStatusUnknown
= 0x7F
814 /// CEC opcodes, as described in the HDMI CEC specification
816 public enum class CecOpcode
823 /// Image view on: power on display for image display
827 /// Text view on: power on display for text display
831 /// Device no longer is the active source
833 InactiveSource
= 0x9D,
835 /// Request which device has the active source status
837 RequestActiveSource
= 0x85,
839 /// Routing change for HDMI switches
841 RoutingChange
= 0x80,
843 /// Routing information for HDMI switches
845 RoutingInformation
= 0x81,
847 /// Change the stream path to the given physical address
849 SetStreamPath
= 0x86,
851 /// Inform that a device went into standby mode
863 /// Recording status information
867 /// Record current display
869 RecordTvScreen
= 0x0F,
871 /// Clear analogue timer
873 ClearAnalogueTimer
= 0x33,
875 /// Clear digital timer
877 ClearDigitalTimer
= 0x99,
879 /// Clear external timer
881 ClearExternalTimer
= 0xA1,
883 /// Set analogue timer
885 SetAnalogueTimer
= 0x34,
887 /// Set digital timer
889 SetDigitalTimer
= 0x97,
891 /// Set external timer
893 SetExternalTimer
= 0xA2,
895 /// Set program title of a timer
897 SetTimerProgramTitle
= 0x67,
899 /// Timer status cleared
901 TimerClearedStatus
= 0x43,
903 /// Timer status information
907 /// CEC version used by a device
911 /// Request CEC version of a device
913 GetCecVersion
= 0x9F,
915 /// Request physical address of a device
917 GivePhysicalAddress
= 0x83,
919 /// Request language code of the menu language of a device
920 /// 3 character ISO 639-2 country code. see http://http://www.loc.gov/standards/iso639-2/
922 GetMenuLanguage
= 0x91,
924 /// Report the physical address
926 ReportPhysicalAddress
= 0x84,
928 /// Report the language code of the menu language
929 /// 3 character ISO 639-2 country code. see http://http://www.loc.gov/standards/iso639-2/
931 SetMenuLanguage
= 0x32,
933 /// Deck control for playback and recording devices
937 /// Deck status for playback and recording devices
941 /// Request deck status from playback and recording devices
943 GiveDeckStatus
= 0x1A,
945 /// Start playback on playback and recording devices
949 /// Request tuner status
951 GiveTunerDeviceStatus
= 0x08,
953 /// Select analogue service on a tuner
955 SelectAnalogueService
= 0x92,
957 /// Select digital service on a tuner
959 SelectDigtalService
= 0x93,
961 /// Report tuner device status
963 TunerDeviceStatus
= 0x07,
965 /// Tuner step decrement
967 TunerStepDecrement
= 0x06,
969 /// Tuner step increment
971 TunerStepIncrement
= 0x05,
973 /// Report device vendor ID
975 DeviceVendorId
= 0x87,
977 /// Request device vendor ID
979 GiveDeviceVendorId
= 0x8C,
981 /// Vendor specific command
983 VendorCommand
= 0x89,
985 /// Vendor specific command with vendor ID
987 VendorCommandWithId
= 0xA0,
989 /// Vendor specific remote button pressed
991 VendorRemoteButtonDown
= 0x8A,
993 /// Vendor specific remote button released
995 VendorRemoteButtonUp
= 0x8B,
997 /// Display / clear OSD string
1001 /// Request device OSD name
1005 /// Report device OSD name
1009 /// Request device menu status
1013 /// Report device menu status
1017 /// Remote button pressed
1019 UserControlPressed
= 0x44,
1021 /// Remote button released
1023 UserControlRelease
= 0x45,
1025 /// Request device power status
1027 GiveDevicePowerStatus
= 0x8F,
1029 /// Report device power status
1031 ReportPowerStatus
= 0x90,
1033 /// Feature abort / unsupported command
1035 FeatureAbort
= 0x00,
1041 /// Give audio status
1043 GiveAudioStatus
= 0x71,
1045 /// Give audiosystem mode
1047 GiveSystemAudioMode
= 0x7D,
1049 /// Report device audio status
1051 ReportAudioStatus
= 0x7A,
1053 /// Set audiosystem mode
1055 SetSystemAudioMode
= 0x72,
1057 /// Request audiosystem mode
1059 SystemAudioModeRequest
= 0x70,
1061 /// Report audiosystem mode
1063 SystemAudioModeStatus
= 0x7E,
1065 /// Set audio bitrate
1067 SetAudioRate
= 0x9A,
1069 /// When this opcode is set, no opcode will be sent to the device / poll message
1070 /// This is one of the reserved numbers
1076 /// Audiosystem status
1078 public enum class CecSystemAudioStatus
1091 /// libCEC client application version
1093 public enum class CecClientVersion
1102 Version1_5_0
= 0x1500,
1106 Version1_5_1
= 0x1501,
1110 Version1_5_2
= 0x1502,
1114 Version1_5_3
= 0x1503,
1118 Version1_6_0
= 0x1600,
1122 Version1_6_1
= 0x1601,
1126 Version1_6_2
= 0x1602,
1130 Version1_6_3
= 0x1603,
1134 Version1_7_0
= 0x1700,
1138 Version1_7_1
= 0x1701,
1142 Version1_7_2
= 0x1702,
1146 Version1_8_0
= 0x1800,
1150 Version1_8_1
= 0x1801,
1154 Version1_8_2
= 0x1802,
1158 Version1_9_0
= 0x1900,
1162 Version1_99_0
= 0x1990,
1166 Version2_0_
= 0x2000
1172 public enum class CecServerVersion
1181 Version1_5_0
= 0x1500,
1185 Version1_5_1
= 0x1501,
1189 Version1_5_2
= 0x1502,
1193 Version1_5_3
= 0x1503,
1197 Version1_6_0
= 0x1600,
1201 Version1_6_1
= 0x1601,
1205 Version1_6_2
= 0x1602,
1209 Version1_6_3
= 0x1603,
1213 Version1_7_0
= 0x1700,
1217 Version1_7_1
= 0x1701,
1221 Version1_7_2
= 0x1702,
1225 Version1_8_0
= 0x1800,
1229 Version1_8_1
= 0x1801,
1233 Version1_8_2
= 0x1802,
1237 Version1_9_0
= 0x1900,
1241 Version1_99_0
= 0x1990,
1245 Version2_0_
= 0x2000
1249 /// Type of adapter to which libCEC is connected
1251 public enum class CecAdapterType
1254 /// Unknown adapter type
1258 /// Pulse-Eight USB-CEC adapter
1260 PulseEightExternal
= 0x1,
1262 /// Pulse-Eight CEC daughterboard
1264 PulseEightDaughterboard
= 0x2,
1272 /// Descriptor of a CEC adapter, returned when scanning for adapters that are connected to the system
1274 public ref
class CecAdapter
1278 /// Create a new CEC adapter descriptor
1280 /// <param name="path"> The path descriptor for this CEC adapter</param>
1281 /// <param name="comPort">The COM port of this CEC adapter</param>
1282 CecAdapter(System::String
^ path
, System::String
^ comPort
)
1289 /// The path descriptor for this CEC adapter
1291 property
System::String
^ Path
;
1294 /// The COM port of this CEC adapter
1296 property
System::String
^ ComPort
;
1300 /// A list of CEC device types
1302 public ref
class CecDeviceTypeList
1306 /// Create a new empty list of CEC device types
1308 CecDeviceTypeList(void)
1310 Types
= gcnew array
<CecDeviceType
>(5);
1311 for (unsigned int iPtr
= 0; iPtr
< 5; iPtr
++)
1312 Types
[iPtr
] = CecDeviceType::Reserved
;
1316 /// The array with CecDeviceType instances in this list.
1318 property array
<CecDeviceType
> ^ Types
;
1322 /// A list of logical addresses
1324 public ref
class CecLogicalAddresses
1328 /// Create a new empty list of logical addresses
1330 CecLogicalAddresses(void)
1332 Addresses
= gcnew array
<CecLogicalAddress
>(16);
1337 /// Clears this list
1341 Primary
= CecLogicalAddress::Unknown
;
1342 for (unsigned int iPtr
= 0; iPtr
< 16; iPtr
++)
1343 Addresses
[iPtr
] = CecLogicalAddress::Unknown
;
1347 /// Checks whether a logical address is set in this list.
1349 /// <param name="address">The address to check.</param>
1350 /// <returns>True when set, false otherwise</returns>
1351 bool IsSet(CecLogicalAddress address
)
1353 return Addresses
[(unsigned int)address
] != CecLogicalAddress::Unknown
;
1357 /// Add a logical address to this list (if it's not set already)
1359 /// <param name="address">The address to add.</param>
1360 void Set(CecLogicalAddress address
)
1362 Addresses
[(unsigned int)address
] = address
;
1363 if (Primary
== CecLogicalAddress::Unknown
)
1368 /// The primary (first) address in this list
1370 property CecLogicalAddress Primary
;
1373 /// The list of addresses
1375 property array
<CecLogicalAddress
> ^ Addresses
;
1380 /// Byte array used for CEC command parameters
1382 public ref
class CecDatapacket
1386 /// Create a new byte array with maximum size 100
1390 Data
= gcnew array
<uint8_t>(100);
1395 /// Adds a byte to this byte array
1397 /// <param name="data">The byte to add.</param>
1398 void PushBack(uint8_t data
)
1410 property array
<uint8_t> ^ Data
;
1413 /// Current data size
1415 property
uint8_t Size
;
1419 /// A CEC command that is received or transmitted over the CEC bus
1421 public ref
class CecCommand
1425 /// Create a new CEC command instance
1427 /// <param name="initiator">The initiator of the command</param>
1428 /// <param name="destination">The receiver of the command</param>
1429 /// <param name="ack">True when the ack bit is set, false otherwise</param>
1430 /// <param name="eom">True when the eom bit is set, false otherwise</param>
1431 /// <param name="opcode">The CEC opcode of this command</param>
1432 /// <param name="transmitTimeout">The timeout to use when transmitting a command</param>
1433 CecCommand(CecLogicalAddress initiator
, CecLogicalAddress destination
, bool ack
, bool eom
, CecOpcode opcode
, int32_t transmitTimeout
)
1435 Initiator
= initiator
;
1436 Destination
= destination
;
1441 TransmitTimeout
= transmitTimeout
;
1442 Parameters
= gcnew CecDatapacket
;
1447 /// Create a new empty CEC command instance
1451 Initiator
= CecLogicalAddress::Unknown
;
1452 Destination
= CecLogicalAddress::Unknown
;
1455 Opcode
= CecOpcode::None
;
1457 TransmitTimeout
= 0;
1458 Parameters
= gcnew CecDatapacket
;
1463 /// Pushes a byte of data to this CEC command
1465 /// <param name="data">The byte to add</param>
1466 void PushBack(uint8_t data
)
1468 if (Initiator
== CecLogicalAddress::Unknown
&& Destination
== CecLogicalAddress::Unknown
)
1470 Initiator
= (CecLogicalAddress
) (data
>> 4);
1471 Destination
= (CecLogicalAddress
) (data
& 0xF);
1473 else if (!OpcodeSet
)
1476 Opcode
= (CecOpcode
)data
;
1480 Parameters
->PushBack(data
);
1485 /// True when this command is empty, false otherwise.
1487 property
bool Empty
;
1489 /// The initiator of the command
1491 property CecLogicalAddress Initiator
;
1493 /// The destination of the command
1495 property CecLogicalAddress Destination
;
1497 /// True when the ack bit is set, false otherwise
1501 /// True when the eom bit is set, false otherwise
1505 /// The CEC opcode of the command
1507 property CecOpcode Opcode
;
1509 /// The parameters of this command
1511 property CecDatapacket
^ Parameters
;
1513 /// True when an opcode is set, false otherwise (poll message)
1515 property
bool OpcodeSet
;
1517 /// The timeout to use when transmitting a command
1519 property
int32_t TransmitTimeout
;
1523 /// A key press that was received
1525 public ref
class CecKeypress
1529 /// Create a new key press instance
1531 /// <param name="keycode">The key code of this key press</param>
1532 /// <param name="duration">The duration of this key press in milliseconds</param>
1533 CecKeypress(CecUserControlCode keycode
, unsigned int duration
)
1536 Duration
= duration
;
1541 /// Create a new empty key press instance
1545 Keycode
= CecUserControlCode::Unknown
;
1551 /// True when empty, false otherwise
1553 property
bool Empty
;
1555 /// The key code of this key press
1557 property CecUserControlCode Keycode
;
1559 /// The duration of this key press in milliseconds
1561 property
unsigned int Duration
;
1565 /// A log message that libCEC generated
1567 public ref
class CecLogMessage
1571 /// Create a new log message
1573 /// <param name="message">The actual message</param>
1574 /// <param name="level">The log level, so the application can choose what type information to display</param>
1575 /// <param name="time">The timestamp of this message, in milliseconds after connecting</param>
1576 CecLogMessage(System::String
^ message
, CecLogLevel level
, int64_t time
)
1585 /// Create a new empty log message
1590 Level
= CecLogLevel::None
;
1596 /// True when empty, false otherwise.
1598 property
bool Empty
;
1600 /// The actual message
1602 property
System::String
^Message
;
1604 /// The log level, so the application can choose what type information to display
1606 property CecLogLevel Level
;
1608 /// The timestamp of this message, in milliseconds after connecting
1610 property
int64_t Time
;
1613 ref
class CecCallbackMethods
; //forward declaration
1616 /// The configuration that libCEC uses.
1618 public ref
class LibCECConfiguration
1622 /// Create a new configuration instance with default settings.
1624 LibCECConfiguration(void)
1627 DeviceTypes
= gcnew
CecDeviceTypeList();
1628 AutodetectAddress
= true;
1629 PhysicalAddress
= CEC_DEFAULT_PHYSICAL_ADDRESS
;
1630 BaseDevice
= (CecLogicalAddress
)CEC_DEFAULT_BASE_DEVICE
;
1631 HDMIPort
= CEC_DEFAULT_HDMI_PORT
;
1632 ClientVersion
= CecClientVersion::VersionPre1_5
;
1633 ServerVersion
= CecServerVersion::VersionPre1_5
;
1634 TvVendor
= CecVendorId::Unknown
;
1636 GetSettingsFromROM
= false;
1637 UseTVMenuLanguage
= CEC_DEFAULT_SETTING_USE_TV_MENU_LANGUAGE
== 1;
1638 ActivateSource
= CEC_DEFAULT_SETTING_ACTIVATE_SOURCE
== 1;
1640 WakeDevices
= gcnew
CecLogicalAddresses();
1641 if (CEC_DEFAULT_SETTING_ACTIVATE_SOURCE
== 1)
1642 WakeDevices
->Set(CecLogicalAddress::Tv
);
1644 PowerOffDevices
= gcnew
CecLogicalAddresses();
1645 if (CEC_DEFAULT_SETTING_POWER_OFF_SHUTDOWN
== 1)
1646 PowerOffDevices
->Set(CecLogicalAddress::Broadcast
);
1648 PowerOffScreensaver
= CEC_DEFAULT_SETTING_POWER_OFF_SCREENSAVER
== 1;
1649 PowerOffOnStandby
= CEC_DEFAULT_SETTING_POWER_OFF_ON_STANDBY
== 1;
1651 SendInactiveSource
= CEC_DEFAULT_SETTING_SEND_INACTIVE_SOURCE
== 1;
1652 LogicalAddresses
= gcnew
CecLogicalAddresses();
1653 FirmwareVersion
= 1;
1654 PowerOffDevicesOnStandby
= CEC_DEFAULT_SETTING_POWER_OFF_DEVICES_STANDBY
== 1;
1655 ShutdownOnStandby
= CEC_DEFAULT_SETTING_SHUTDOWN_ON_STANDBY
== 1;
1656 DeviceLanguage
= "";
1657 FirmwareBuildDate
= gcnew
System::DateTime(1970,1,1,0,0,0,0);
1658 CECVersion
= (CecVersion
)CEC_DEFAULT_SETTING_CEC_VERSION
;
1659 AdapterType
= CecAdapterType::Unknown
;
1663 /// Change the callback method pointers in this configuration instance.
1665 /// <param name="callbacks">The new callbacks</param>
1666 void SetCallbacks(CecCallbackMethods
^callbacks
)
1668 Callbacks
= callbacks
;
1672 /// Update this configuration with data received from libCEC
1674 /// <param name="config">The configuration that was received from libCEC</param>
1675 void Update(const CEC::libcec_configuration
&config
)
1677 DeviceName
= gcnew
System::String(config
.strDeviceName
);
1679 for (unsigned int iPtr
= 0; iPtr
< 5; iPtr
++)
1680 DeviceTypes
->Types
[iPtr
] = (CecDeviceType
)config
.deviceTypes
.types
[iPtr
];
1682 AutodetectAddress
= config
.bAutodetectAddress
== 1;
1683 PhysicalAddress
= config
.iPhysicalAddress
;
1684 BaseDevice
= (CecLogicalAddress
)config
.baseDevice
;
1685 HDMIPort
= config
.iHDMIPort
;
1686 ClientVersion
= (CecClientVersion
)config
.clientVersion
;
1687 ServerVersion
= (CecServerVersion
)config
.serverVersion
;
1688 TvVendor
= (CecVendorId
)config
.tvVendor
;
1690 // player specific settings
1691 GetSettingsFromROM
= config
.bGetSettingsFromROM
== 1;
1692 UseTVMenuLanguage
= config
.bUseTVMenuLanguage
== 1;
1693 ActivateSource
= config
.bActivateSource
== 1;
1695 WakeDevices
->Clear();
1696 for (uint8_t iPtr
= 0; iPtr
<= 16; iPtr
++)
1697 if (config
.wakeDevices
[iPtr
])
1698 WakeDevices
->Set((CecLogicalAddress
)iPtr
);
1700 PowerOffDevices
->Clear();
1701 for (uint8_t iPtr
= 0; iPtr
<= 16; iPtr
++)
1702 if (config
.powerOffDevices
[iPtr
])
1703 PowerOffDevices
->Set((CecLogicalAddress
)iPtr
);
1705 PowerOffScreensaver
= config
.bPowerOffScreensaver
== 1;
1706 PowerOffOnStandby
= config
.bPowerOffOnStandby
== 1;
1708 if (ServerVersion
>= CecServerVersion::Version1_5_1
)
1709 SendInactiveSource
= config
.bSendInactiveSource
== 1;
1711 if (ServerVersion
>= CecServerVersion::Version1_5_3
)
1713 LogicalAddresses
->Clear();
1714 for (uint8_t iPtr
= 0; iPtr
<= 16; iPtr
++)
1715 if (config
.logicalAddresses
[iPtr
])
1716 LogicalAddresses
->Set((CecLogicalAddress
)iPtr
);
1719 if (ServerVersion
>= CecServerVersion::Version1_6_0
)
1721 FirmwareVersion
= config
.iFirmwareVersion
;
1722 PowerOffDevicesOnStandby
= config
.bPowerOffDevicesOnStandby
== 1;
1723 ShutdownOnStandby
= config
.bShutdownOnStandby
== 1;
1726 if (ServerVersion
>= CecServerVersion::Version1_6_2
)
1728 DeviceLanguage
= gcnew
System::String(config
.strDeviceLanguage
);
1729 FirmwareBuildDate
= gcnew
System::DateTime(1970,1,1,0,0,0,0);
1730 FirmwareBuildDate
= FirmwareBuildDate
->AddSeconds(config
.iFirmwareBuildDate
);
1733 if (ServerVersion
>= CecServerVersion::Version1_6_3
)
1734 MonitorOnlyClient
= config
.bMonitorOnly
== 1;
1736 if (ServerVersion
>= CecServerVersion::Version1_8_0
)
1737 CECVersion
= (CecVersion
)config
.cecVersion
;
1739 if (ServerVersion
>= CecServerVersion::Version1_8_2
)
1740 AdapterType
= (CecAdapterType
)config
.adapterType
;
1744 /// The device name to use on the CEC bus
1746 property
System::String
^ DeviceName
;
1749 /// The device type(s) to use on the CEC bus for libCEC
1751 property CecDeviceTypeList
^ DeviceTypes
;
1754 /// (read only) set to true by libCEC when the physical address was autodetected
1756 property
bool AutodetectAddress
;
1759 /// The physical address of the CEC adapter
1761 property
uint16_t PhysicalAddress
;
1764 /// 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
1766 property CecLogicalAddress BaseDevice
;
1769 /// The HDMI port to which the adapter is connected. Only used when iPhysicalAddress = 0 or when the adapter doesn't support autodetection
1771 property
uint8_t HDMIPort
;
1774 /// The client API version to use
1776 property CecClientVersion ClientVersion
;
1779 /// The version of libCEC
1781 property CecServerVersion ServerVersion
;
1784 /// Override the vendor ID of the TV. Leave this untouched to autodetect
1786 property CecVendorId TvVendor
;
1789 /// True to read the settings from the EEPROM, which possibly override the settings passed here
1791 property
bool GetSettingsFromROM
;
1794 /// Use the language setting of the TV in the client application. Must be implemented by the client application.
1795 /// 3 character ISO 639-2 country code. see http://http://www.loc.gov/standards/iso639-2/
1797 property
bool UseTVMenuLanguage
;
1800 /// Make libCEC the active source when starting the client application
1802 property
bool ActivateSource
;
1805 /// List of devices to wake when initialising libCEC or when calling PowerOnDevices() without any parameter.
1807 property CecLogicalAddresses
^WakeDevices
;
1810 /// List of devices to power off when calling StandbyDevices() without any parameter.
1812 property CecLogicalAddresses
^PowerOffDevices
;
1815 /// Send standby commands when the client application activates the screensaver. Must be implemented by the client application.
1817 property
bool PowerOffScreensaver
;
1820 /// Power off the PC when the TV powers off. Must be implemented by the client application.
1822 property
bool PowerOffOnStandby
;
1825 /// Send an inactive source message when exiting the client application.
1827 property
bool SendInactiveSource
;
1830 /// The list of logical addresses that libCEC is using
1832 property CecLogicalAddresses
^LogicalAddresses
;
1835 /// The firmware version of the adapter to which libCEC is connected
1837 property
uint16_t FirmwareVersion
;
1840 /// Send standby commands when the client application activates standby mode (S3). Must be implemented by the client application.
1842 property
bool PowerOffDevicesOnStandby
;
1845 /// Shutdown this PC when the TV is switched off. only used when PowerOffOnStandby = false
1847 property
bool ShutdownOnStandby
;
1850 /// True to start a monitor-only client, false to start a standard client.
1852 property
bool MonitorOnlyClient
;
1855 /// The language code of the menu language that libCEC reports to other devices.
1856 /// 3 character ISO 639-2 country code. see http://http://www.loc.gov/standards/iso639-2/
1858 property
System::String
^ DeviceLanguage
;
1861 /// The callback methods to use.
1863 property CecCallbackMethods
^ Callbacks
;
1866 /// The build date of the firmware.
1868 property
System::DateTime
^ FirmwareBuildDate
;
1871 /// The CEC version that libCEC uses.
1873 property CecVersion CECVersion
;
1876 /// The type of adapter that libCEC is connected to.
1878 property CecAdapterType AdapterType
;
1881 // the callback methods are called by unmanaged code, so we need some delegates for this
1883 // unmanaged callback methods
1884 typedef int (__stdcall
*LOGCB
) (const CEC::cec_log_message
&message
);
1885 typedef int (__stdcall
*KEYCB
) (const CEC::cec_keypress
&key
);
1886 typedef int (__stdcall
*COMMANDCB
)(const CEC::cec_command
&command
);
1887 typedef int (__stdcall
*CONFIGCB
) (const CEC::libcec_configuration
&config
);
1888 typedef int (__stdcall
*ALERTCB
) (const CEC::libcec_alert
, const CEC::libcec_parameter
&data
);
1889 typedef int (__stdcall
*MENUCB
) (const CEC::cec_menu_state newVal
);
1890 typedef void (__stdcall
*ACTICB
) (const CEC::cec_logical_address logicalAddress
, const uint8_t bActivated
);
1893 /// libCEC callback methods. Unmanaged code.
1898 /// Log message callback
1902 /// Key press/release callback
1906 /// Raw CEC data callback
1908 COMMANDCB commandCB
;
1910 /// Updated configuration callback
1914 /// Alert message callback
1918 /// Menu status change callback
1922 /// Source (de)activated callback
1924 ACTICB sourceActivatedCB
;
1925 } UnmanagedCecCallbacks
;
1927 static PLATFORM::CMutex g_callbackMutex
;
1928 static std::vector
<UnmanagedCecCallbacks
> g_unmanagedCallbacks
;
1929 static CEC::ICECCallbacks g_cecCallbacks
;
1932 /// Called by libCEC to send back a log message to the application
1934 /// <param name="cbParam">Pointer to the callback struct</param>
1935 /// <param name="message">The log message</param>
1936 /// <return>1 when handled, 0 otherwise</return>
1937 int CecLogMessageCB(void *cbParam
, const CEC::cec_log_message
&message
)
1941 size_t iPtr
= (size_t)cbParam
;
1942 PLATFORM::CLockObject
lock(g_callbackMutex
);
1943 if (iPtr
>= 0 && iPtr
< g_unmanagedCallbacks
.size())
1944 return g_unmanagedCallbacks
[iPtr
].logCB(message
);
1950 /// Called by libCEC to send back a key press or release to the application
1952 /// <param name="cbParam">Pointer to the callback struct</param>
1953 /// <param name="key">The key press command that libCEC received</param>
1954 /// <return>1 when handled, 0 otherwise</return>
1955 int CecKeyPressCB(void *cbParam
, const CEC::cec_keypress
&key
)
1959 size_t iPtr
= (size_t)cbParam
;
1960 PLATFORM::CLockObject
lock(g_callbackMutex
);
1961 if (iPtr
>= 0 && iPtr
< g_unmanagedCallbacks
.size())
1962 return g_unmanagedCallbacks
[iPtr
].keyCB(key
);
1968 /// Called by libCEC to send back raw CEC data to the application
1970 /// <param name="cbParam">Pointer to the callback struct</param>
1971 /// <param name="command">The raw CEC data</param>
1972 /// <return>1 when handled, 0 otherwise</return>
1973 int CecCommandCB(void *cbParam
, const CEC::cec_command
&command
)
1977 size_t iPtr
= (size_t)cbParam
;
1978 PLATFORM::CLockObject
lock(g_callbackMutex
);
1979 if (iPtr
>= 0 && iPtr
< g_unmanagedCallbacks
.size())
1980 return g_unmanagedCallbacks
[iPtr
].commandCB(command
);
1986 /// Called by libCEC to send back an updated configuration to the application
1988 /// <param name="cbParam">Pointer to the callback struct</param>
1989 /// <param name="config">The new configuration</param>
1990 /// <return>1 when handled, 0 otherwise</return>
1991 int CecConfigCB(void *cbParam
, const CEC::libcec_configuration
&config
)
1995 size_t iPtr
= (size_t)cbParam
;
1996 PLATFORM::CLockObject
lock(g_callbackMutex
);
1997 if (iPtr
>= 0 && iPtr
< g_unmanagedCallbacks
.size())
1998 return g_unmanagedCallbacks
[iPtr
].configCB(config
);
2004 /// Called by libCEC to send back an alert message to the application
2006 /// <param name="cbParam">Pointer to the callback struct</param>
2007 /// <param name="data">The alert message</param>
2008 /// <return>1 when handled, 0 otherwise</return>
2009 int CecAlertCB(void *cbParam
, const CEC::libcec_alert alert
, const CEC::libcec_parameter
&data
)
2013 size_t iPtr
= (size_t)cbParam
;
2014 PLATFORM::CLockObject
lock(g_callbackMutex
);
2015 if (iPtr
>= 0 && iPtr
< g_unmanagedCallbacks
.size())
2016 return g_unmanagedCallbacks
[iPtr
].alertCB(alert
, data
);
2022 /// Called by libCEC to send back a menu state change to the application
2024 /// <param name="cbParam">Pointer to the callback struct</param>
2025 /// <param name="newVal">The new menu state</param>
2026 /// <return>1 when handled, 0 otherwise</return>
2027 int CecMenuCB(void *cbParam
, const CEC::cec_menu_state newVal
)
2031 size_t iPtr
= (size_t)cbParam
;
2032 PLATFORM::CLockObject
lock(g_callbackMutex
);
2033 if (iPtr
>= 0 && iPtr
< g_unmanagedCallbacks
.size())
2034 return g_unmanagedCallbacks
[iPtr
].menuCB(newVal
);
2040 /// Called by libCEC to notify the application that the source that is handled by libCEC was (de)activated
2042 /// <param name="cbParam">Pointer to the callback struct</param>
2043 /// <param name="logicalAddress">The logical address that was (de)activated</param>
2044 /// <param name="activated">True when activated, false when deactivated</param>
2045 void CecSourceActivatedCB(void *cbParam
, const CEC::cec_logical_address logicalAddress
, const uint8_t activated
)
2049 size_t iPtr
= (size_t)cbParam
;
2050 PLATFORM::CLockObject
lock(g_callbackMutex
);
2051 if (iPtr
>= 0 && iPtr
< g_unmanagedCallbacks
.size())
2052 g_unmanagedCallbacks
[iPtr
].sourceActivatedCB(logicalAddress
, activated
);
2058 /// Delegate method for the CecLogMessageCB callback in CecCallbackMethods
2060 public delegate
int CecLogMessageManagedDelegate(const CEC::cec_log_message
&);
2062 /// Delegate method for the CecKeyPressCB callback in CecCallbackMethods
2064 public delegate
int CecKeyPressManagedDelegate(const CEC::cec_keypress
&);
2066 /// Delegate method for the CecCommandCB callback in CecCallbackMethods
2068 public delegate
int CecCommandManagedDelegate(const CEC::cec_command
&);
2070 /// Delegate method for the CecConfigCB callback in CecCallbackMethods
2072 public delegate
int CecConfigManagedDelegate(const CEC::libcec_configuration
&);
2074 /// Delegate method for the CecAlertCB callback in CecCallbackMethods
2076 public delegate
int CecAlertManagedDelegate(const CEC::libcec_alert
, const CEC::libcec_parameter
&);
2078 /// Delegate method for the CecMenuCB callback in CecCallbackMethods
2080 public delegate
int CecMenuManagedDelegate(const CEC::cec_menu_state
);
2082 /// Delegate method for the CecSourceActivatedCB callback in CecCallbackMethods
2084 public delegate
void CecSourceActivatedManagedDelegate(const CEC::cec_logical_address
, const uint8_t);
2087 /// Assign the callback methods in the g_cecCallbacks struct
2089 void AssignCallbacks()
2091 g_cecCallbacks
.CBCecLogMessage
= CecLogMessageCB
;
2092 g_cecCallbacks
.CBCecKeyPress
= CecKeyPressCB
;
2093 g_cecCallbacks
.CBCecCommand
= CecCommandCB
;
2094 g_cecCallbacks
.CBCecConfigurationChanged
= CecConfigCB
;
2095 g_cecCallbacks
.CBCecAlert
= CecAlertCB
;
2096 g_cecCallbacks
.CBCecMenuStateChanged
= CecMenuCB
;
2097 g_cecCallbacks
.CBCecSourceActivated
= CecSourceActivatedCB
;
2101 /// The callback methods that libCEC uses
2103 public ref
class CecCallbackMethods
2106 CecCallbackMethods(void)
2108 m_iCallbackPtr
= -1;
2110 m_bHasCallbacks
= false;
2111 m_bDelegatesCreated
= false;
2114 ~CecCallbackMethods(void)
2120 /// Pointer to the callbacks struct entry
2122 size_t GetCallbackPtr(void)
2124 PLATFORM::CLockObject
lock(g_callbackMutex
);
2125 return m_iCallbackPtr
;
2129 !CecCallbackMethods(void)
2136 /// Disable callback methods
2138 virtual void DisableCallbacks(void)
2144 /// Enable callback methods
2146 /// <param name="callbacks">Callback methods to activate</param>
2147 /// <return>true when handled, false otherwise</return>
2148 virtual bool EnableCallbacks(CecCallbackMethods
^ callbacks
)
2151 if (!m_bHasCallbacks
)
2153 m_bHasCallbacks
= true;
2154 m_callbacks
= callbacks
;
2162 /// Called by libCEC to send back a log message to the application.
2163 /// Override in the application to handle this callback.
2165 /// <param name="message">The log message</param>
2166 /// <return>1 when handled, 0 otherwise</return>
2167 virtual int ReceiveLogMessage(CecLogMessage
^ message
)
2173 /// Called by libCEC to send back a key press or release to the application.
2174 /// Override in the application to handle this callback.
2176 /// <param name="key">The key press command that libCEC received</param>
2177 /// <return>1 when handled, 0 otherwise</return>
2178 virtual int ReceiveKeypress(CecKeypress
^ key
)
2184 /// Called by libCEC to send back raw CEC data to the application.
2185 /// Override in the application to handle this callback.
2187 /// <param name="command">The raw CEC data</param>
2188 /// <return>1 when handled, 0 otherwise</return>
2189 virtual int ReceiveCommand(CecCommand
^ command
)
2195 /// Called by libCEC to send back an updated configuration to the application.
2196 /// Override in the application to handle this callback.
2198 /// <param name="config">The new configuration</param>
2199 /// <return>1 when handled, 0 otherwise</return>
2200 virtual int ConfigurationChanged(LibCECConfiguration
^ config
)
2206 /// Called by libCEC to send back an alert message to the application.
2207 /// Override in the application to handle this callback.
2209 /// <param name="data">The alert message</param>
2210 /// <return>1 when handled, 0 otherwise</return>
2211 virtual int ReceiveAlert(CecAlert alert
, CecParameter
^ data
)
2217 /// Called by libCEC to send back a menu state change to the application.
2218 /// Override in the application to handle this callback.
2220 /// <param name="newVal">The new menu state</param>
2221 /// <return>1 when handled, 0 otherwise</return>
2222 virtual int ReceiveMenuStateChange(CecMenuState newVal
)
2228 /// Called by libCEC to notify the application that the source that is handled by libCEC was (de)activated.
2229 /// Override in the application to handle this callback.
2231 /// <param name="logicalAddress">The logical address that was (de)activated</param>
2232 /// <param name="activated">True when activated, false when deactivated</param>
2233 virtual void SourceActivated(CecLogicalAddress logicalAddress
, bool activated
)
2238 // managed callback methods
2239 int CecLogMessageManaged(const CEC::cec_log_message
&message
)
2242 if (m_bHasCallbacks
)
2243 iReturn
= m_callbacks
->ReceiveLogMessage(gcnew
CecLogMessage(gcnew
System::String(message
.message
), (CecLogLevel
)message
.level
, message
.time
));
2247 int CecKeyPressManaged(const CEC::cec_keypress
&key
)
2250 if (m_bHasCallbacks
)
2251 iReturn
= m_callbacks
->ReceiveKeypress(gcnew
CecKeypress((CecUserControlCode
)key
.keycode
, key
.duration
));
2255 int CecCommandManaged(const CEC::cec_command
&command
)
2258 if (m_bHasCallbacks
)
2260 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
);
2261 for (uint8_t iPtr
= 0; iPtr
< command
.parameters
.size
; iPtr
++)
2262 newCommand
->Parameters
->PushBack(command
.parameters
[iPtr
]);
2263 iReturn
= m_callbacks
->ReceiveCommand(newCommand
);
2268 int CecConfigManaged(const CEC::libcec_configuration
&config
)
2271 if (m_bHasCallbacks
)
2273 LibCECConfiguration
^netConfig
= gcnew
LibCECConfiguration();
2274 netConfig
->Update(config
);
2275 iReturn
= m_callbacks
->ConfigurationChanged(netConfig
);
2280 int CecAlertManaged(const CEC::libcec_alert alert
, const CEC::libcec_parameter
&data
)
2283 if (m_bHasCallbacks
)
2285 CecParameterType newType
= (CecParameterType
)data
.paramType
;
2286 if (newType
== CecParameterType::ParameterTypeString
)
2288 System::String
^ newData
= gcnew
System::String((const char *)data
.paramData
, 0, 128);
2289 CecParameter
^ newParam
= gcnew
CecParameter(newType
, newData
);
2290 iReturn
= m_callbacks
->ReceiveAlert((CecAlert
)alert
, newParam
);
2296 int CecMenuManaged(const CEC::cec_menu_state newVal
)
2299 if (m_bHasCallbacks
)
2301 iReturn
= m_callbacks
->ReceiveMenuStateChange((CecMenuState
)newVal
);
2306 void CecSourceActivatedManaged(const CEC::cec_logical_address logicalAddress
, const uint8_t bActivated
)
2308 if (m_bHasCallbacks
)
2309 m_callbacks
->SourceActivated((CecLogicalAddress
)logicalAddress
, bActivated
== 1);
2312 void DestroyDelegates()
2314 m_bHasCallbacks
= false;
2315 if (m_bDelegatesCreated
)
2317 m_bDelegatesCreated
= false;
2318 m_logMessageGCHandle
.Free();
2319 m_keypressGCHandle
.Free();
2320 m_commandGCHandle
.Free();
2321 m_alertGCHandle
.Free();
2322 m_menuGCHandle
.Free();
2323 m_sourceActivatedGCHandle
.Free();
2327 void CreateDelegates()
2331 if (!m_bDelegatesCreated
)
2333 msclr::interop::marshal_context
^ context
= gcnew
msclr::interop::marshal_context();
2335 // create the delegate method for the log message callback
2336 m_logMessageDelegate
= gcnew
CecLogMessageManagedDelegate(this, &CecCallbackMethods::CecLogMessageManaged
);
2337 m_logMessageGCHandle
= System::Runtime::InteropServices::GCHandle::Alloc(m_logMessageDelegate
);
2338 m_logMessageCallback
= static_cast<LOGCB
>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_logMessageDelegate
).ToPointer());
2340 // create the delegate method for the keypress callback
2341 m_keypressDelegate
= gcnew
CecKeyPressManagedDelegate(this, &CecCallbackMethods::CecKeyPressManaged
);
2342 m_keypressGCHandle
= System::Runtime::InteropServices::GCHandle::Alloc(m_keypressDelegate
);
2343 m_keypressCallback
= static_cast<KEYCB
>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_keypressDelegate
).ToPointer());
2345 // create the delegate method for the command callback
2346 m_commandDelegate
= gcnew
CecCommandManagedDelegate(this, &CecCallbackMethods::CecCommandManaged
);
2347 m_commandGCHandle
= System::Runtime::InteropServices::GCHandle::Alloc(m_commandDelegate
);
2348 m_commandCallback
= static_cast<COMMANDCB
>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_commandDelegate
).ToPointer());
2350 // create the delegate method for the configuration change callback
2351 m_configDelegate
= gcnew
CecConfigManagedDelegate(this, &CecCallbackMethods::CecConfigManaged
);
2352 m_configGCHandle
= System::Runtime::InteropServices::GCHandle::Alloc(m_configDelegate
);
2353 m_configCallback
= static_cast<CONFIGCB
>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_configDelegate
).ToPointer());
2355 // create the delegate method for the alert callback
2356 m_alertDelegate
= gcnew
CecAlertManagedDelegate(this, &CecCallbackMethods::CecAlertManaged
);
2357 m_alertGCHandle
= System::Runtime::InteropServices::GCHandle::Alloc(m_alertDelegate
);
2358 m_alertCallback
= static_cast<ALERTCB
>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_alertDelegate
).ToPointer());
2360 // create the delegate method for the menu callback
2361 m_menuDelegate
= gcnew
CecMenuManagedDelegate(this, &CecCallbackMethods::CecMenuManaged
);
2362 m_menuGCHandle
= System::Runtime::InteropServices::GCHandle::Alloc(m_menuDelegate
);
2363 m_menuCallback
= static_cast<MENUCB
>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_menuDelegate
).ToPointer());
2365 // create the delegate method for the source activated callback
2366 m_sourceActivatedDelegate
= gcnew
CecSourceActivatedManagedDelegate(this, &CecCallbackMethods::CecSourceActivatedManaged
);
2367 m_sourceActivatedGCHandle
= System::Runtime::InteropServices::GCHandle::Alloc(m_sourceActivatedDelegate
);
2368 m_sourceActivatedCallback
= static_cast<ACTICB
>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_sourceActivatedDelegate
).ToPointer());
2372 UnmanagedCecCallbacks unmanagedCallbacks
;
2373 unmanagedCallbacks
.logCB
= m_logMessageCallback
;
2374 unmanagedCallbacks
.keyCB
= m_keypressCallback
;
2375 unmanagedCallbacks
.commandCB
= m_commandCallback
;
2376 unmanagedCallbacks
.configCB
= m_configCallback
;
2377 unmanagedCallbacks
.alertCB
= m_alertCallback
;
2378 unmanagedCallbacks
.menuCB
= m_menuCallback
;
2379 unmanagedCallbacks
.sourceActivatedCB
= m_sourceActivatedCallback
;
2381 PLATFORM::CLockObject
lock(g_callbackMutex
);
2382 g_unmanagedCallbacks
.push_back(unmanagedCallbacks
);
2383 m_iCallbackPtr
= g_unmanagedCallbacks
.size() - 1;
2384 m_bDelegatesCreated
= true;
2388 CecLogMessageManagedDelegate
^ m_logMessageDelegate
;
2389 static System::Runtime::InteropServices::GCHandle m_logMessageGCHandle
;
2390 LOGCB m_logMessageCallback
;
2392 CecKeyPressManagedDelegate
^ m_keypressDelegate
;
2393 static System::Runtime::InteropServices::GCHandle m_keypressGCHandle
;
2394 KEYCB m_keypressCallback
;
2396 CecCommandManagedDelegate
^ m_commandDelegate
;
2397 static System::Runtime::InteropServices::GCHandle m_commandGCHandle
;
2398 COMMANDCB m_commandCallback
;
2400 CecConfigManagedDelegate
^ m_configDelegate
;
2401 static System::Runtime::InteropServices::GCHandle m_configGCHandle
;
2402 CONFIGCB m_configCallback
;
2404 CecAlertManagedDelegate
^ m_alertDelegate
;
2405 static System::Runtime::InteropServices::GCHandle m_alertGCHandle
;
2406 ALERTCB m_alertCallback
;
2408 CecMenuManagedDelegate
^ m_menuDelegate
;
2409 static System::Runtime::InteropServices::GCHandle m_menuGCHandle
;
2410 MENUCB m_menuCallback
;
2412 CecSourceActivatedManagedDelegate
^ m_sourceActivatedDelegate
;
2413 static System::Runtime::InteropServices::GCHandle m_sourceActivatedGCHandle
;
2414 ACTICB m_sourceActivatedCallback
;
2416 CecCallbackMethods
^ m_callbacks
;
2417 bool m_bHasCallbacks
;
2418 bool m_bDelegatesCreated
;
2419 size_t m_iCallbackPtr
;