repositories / deb_libcec.git / blob
? search:


f17ee610162d3778f2c937a79cd3beb7305d3ecb
[deb_libcec.git] / src / LibCecSharp / CecSharpTypes.h
1 #pragma once
2 /*
3 * This file is part of the libCEC(R) library.
4 *
5 * libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited. All rights reserved.
6 * libCEC(R) is an original work, containing original code.
7 *
8 * libCEC(R) is a trademark of Pulse-Eight Limited.
9 *
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.
14 *
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.
19 *
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.
23 *
24 *
25 * Alternatively, you can license this library under a commercial license,
26 * please contact Pulse-Eight Licensing for more information.
27 *
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/
32 */
33
34 #include <windows.h>
35 #include <vcclr.h>
36 #include <msclr/marshal.h>
37 #include "../../include/cec.h"
38
39 #using <System.dll>
40
41 namespace CecSharp
42 {
43 public enum class CecDeviceType
44 {
45 Tv = 0,
46 RecordingDevice = 1,
47 Reserved = 2,
48 Tuner = 3,
49 PlaybackDevice = 4,
50 AudioSystem = 5
51 };
52
53 public enum class CecLogLevel
54 {
55 None = 0,
56 Error = 1,
57 Warning = 2,
58 Notice = 4,
59 Traffic = 8,
60 Debug = 16,
61 All = 31
62 };
63
64 public enum class CecLogicalAddress
65 {
66 Unknown = -1, //not a valid logical address
67 Tv = 0,
68 RecordingDevice1 = 1,
69 RecordingDevice2 = 2,
70 Tuner1 = 3,
71 PlaybackDevice1 = 4,
72 AudioSystem = 5,
73 Tuner2 = 6,
74 Tuner3 = 7,
75 PlaybackDevice2 = 8,
76 RecordingDevice3 = 9,
77 Tuner4 = 10,
78 PlaybackDevice3 = 11,
79 Reserved1 = 12,
80 Reserved2 = 13,
81 FreeUse = 14,
82 Unregistered = 15,
83 Broadcast = 15
84 };
85
86 public enum class CecAlert
87 {
88 ServiceDevice = 1
89 };
90
91 public enum class CecParameterType
92 {
93 ParameterTypeString = 1
94 };
95
96 public ref class CecParameter
97 {
98 public:
99 CecParameter(CecParameterType type, System::String ^ strData)
100 {
101 Type = type;
102 Data = strData;
103 }
104
105 property CecParameterType Type;
106 property System::String ^ Data;
107 };
108
109 public enum class CecPowerStatus
110 {
111 On = 0x00,
112 Standby = 0x01,
113 InTransitionStandbyToOn = 0x02,
114 InTransitionOnToStandby = 0x03,
115 Unknown = 0x99
116 };
117
118 public enum class CecVersion
119 {
120 Unknown = 0x00,
121 V1_2 = 0x01,
122 V1_2A = 0x02,
123 V1_3 = 0x03,
124 V1_3A = 0x04,
125 V1_4 = 0x05
126 };
127
128 public enum class CecDisplayControl
129 {
130 DisplayForDefaultTime = 0x00,
131 DisplayUntilCleared = 0x40,
132 ClearPreviousMessage = 0x80,
133 ReservedForFutureUse = 0xC0
134 };
135
136 public enum class CecMenuState
137 {
138 Activated = 0,
139 Deactivated = 1
140 };
141
142 public enum class CecDeckControlMode
143 {
144 SkipForwardWind = 1,
145 SkipReverseRewind = 2,
146 Stop = 3,
147 Eject = 4
148 };
149
150 public enum class CecDeckInfo
151 {
152 Play = 0x11,
153 Record = 0x12,
154 Reverse = 0x13,
155 Still = 0x14,
156 Slow = 0x15,
157 SlowReverse = 0x16,
158 FastForward = 0x17,
159 FastReverse = 0x18,
160 NoMedia = 0x19,
161 Stop = 0x1A,
162 SkipForwardWind = 0x1B,
163 SkipReverseRewind = 0x1C,
164 IndexSearchForward = 0x1D,
165 IndexSearchReverse = 0x1E,
166 OtherStatus = 0x1F
167 };
168
169 public enum class CecUserControlCode
170 {
171 Select = 0x00,
172 Up = 0x01,
173 Down = 0x02,
174 Left = 0x03,
175 Right = 0x04,
176 RightUp = 0x05,
177 RightDown = 0x06,
178 LeftUp = 0x07,
179 LeftDown = 0x08,
180 RootMenu = 0x09,
181 SetupMenu = 0x0A,
182 ContentsMenu = 0x0B,
183 FavoriteMenu = 0x0C,
184 Exit = 0x0D,
185 Number0 = 0x20,
186 Number1 = 0x21,
187 Number2 = 0x22,
188 Number3 = 0x23,
189 Number4 = 0x24,
190 Number5 = 0x25,
191 Number6 = 0x26,
192 Number7 = 0x27,
193 Number8 = 0x28,
194 Number9 = 0x29,
195 Dot = 0x2A,
196 Enter = 0x2B,
197 Clear = 0x2C,
198 NextFavorite = 0x2F,
199 ChannelUp = 0x30,
200 ChannelDown = 0x31,
201 PreviousChannel = 0x32,
202 SoundSelect = 0x33,
203 InputSelect = 0x34,
204 DisplayInformation = 0x35,
205 Help = 0x36,
206 PageUp = 0x37,
207 PageDown = 0x38,
208 Power = 0x40,
209 VolumeUp = 0x41,
210 VolumeDown = 0x42,
211 Mute = 0x43,
212 Play = 0x44,
213 Stop = 0x45,
214 Pause = 0x46,
215 Record = 0x47,
216 Rewind = 0x48,
217 FastForward = 0x49,
218 Eject = 0x4A,
219 Forward = 0x4B,
220 Backward = 0x4C,
221 StopRecord = 0x4D,
222 PauseRecord = 0x4E,
223 Angle = 0x50,
224 SubPicture = 0x51,
225 VideoOnDemand = 0x52,
226 ElectronicProgramGuide = 0x53,
227 TimerProgramming = 0x54,
228 InitialConfiguration = 0x55,
229 PlayFunction = 0x60,
230 PausePlayFunction = 0x61,
231 RecordFunction = 0x62,
232 PauseRecordFunction = 0x63,
233 StopFunction = 0x64,
234 MuteFunction = 0x65,
235 RestoreVolumeFunction = 0x66,
236 TuneFunction = 0x67,
237 SelectMediaFunction = 0x68,
238 SelectAVInputFunction = 0x69,
239 SelectAudioInputFunction = 0x6A,
240 PowerToggleFunction = 0x6B,
241 PowerOffFunction = 0x6C,
242 PowerOnFunction = 0x6D,
243 F1Blue = 0x71,
244 F2Red = 0X72,
245 F3Green = 0x73,
246 F4Yellow = 0x74,
247 F5 = 0x75,
248 Data = 0x76,
249 Max = 0x76,
250 SamsungReturn = 0x91,
251 Unknown
252 };
253
254 public enum class CecVendorId
255 {
256 Samsung = 0x00F0,
257 LG = 0xE091,
258 Panasonic = 0x8045,
259 Pioneer = 0xE036,
260 Onkyo = 0x09B0,
261 Yamaha = 0xA0DE,
262 Philips = 0x903E,
263 Sony = 0x080046,
264 Unknown = 0
265 };
266
267 public enum class CecAudioStatus
268 {
269 MuteStatusMask = 0x80,
270 VolumeStatusMask = 0x7F,
271 VolumeMin = 0x00,
272 VolumeMax = 0x64,
273 VolumeStatusUnknown = 0x7F
274 };
275
276 public enum class CecOpcode
277 {
278 ActiveSource = 0x82,
279 ImageViewOn = 0x04,
280 TextViewOn = 0x0D,
281 InactiveSource = 0x9D,
282 RequestActiveSource = 0x85,
283 RoutingChange = 0x80,
284 RoutingInformation = 0x81,
285 SetStreamPath = 0x86,
286 Standby = 0x36,
287 RecordOff = 0x0B,
288 RecordOn = 0x09,
289 RecordStatus = 0x0A,
290 RecordTvScreen = 0x0F,
291 ClearAnalogueTimer = 0x33,
292 ClearDigitalTimer = 0x99,
293 ClearExternalTimer = 0xA1,
294 SetAnalogueTimer = 0x34,
295 SetDigitalTimer = 0x97,
296 SetExternalTimer = 0xA2,
297 SetTimerProgramTitle = 0x67,
298 TimerClearedStatus = 0x43,
299 TimerStatus = 0x35,
300 CecVersion = 0x9E,
301 GetCecVersion = 0x9F,
302 GivePhysicalAddress = 0x83,
303 GetMenuLanguage = 0x91,
304 ReportPhysicalAddress = 0x84,
305 SetMenuLanguage = 0x32,
306 DeckControl = 0x42,
307 DeckStatus = 0x1B,
308 GiveDeckStatus = 0x1A,
309 Play = 0x41,
310 GiveTunerDeviceStatus = 0x08,
311 SelectAnalogueService = 0x92,
312 SelectDigtalService = 0x93,
313 TunerDeviceStatus = 0x07,
314 TunerStepDecrement = 0x06,
315 TunerStepIncrement = 0x05,
316 DeviceVendorId = 0x87,
317 GiveDeviceVendorId = 0x8C,
318 VendorCommand = 0x89,
319 VendorCommandWithId = 0xA0,
320 VendorRemoteButtonDown = 0x8A,
321 VendorRemoteButtonUp = 0x8B,
322 SetOsdString = 0x64,
323 GiveOsdName = 0x46,
324 SetOsdName = 0x47,
325 MenuRequest = 0x8D,
326 MenuStatus = 0x8E,
327 UserControlPressed = 0x44,
328 UserControlRelease = 0x45,
329 GiveDevicePowerStatus = 0x8F,
330 ReportPowerStatus = 0x90,
331 FeatureAbort = 0x00,
332 Abort = 0xFF,
333 GiveAudioStatus = 0x71,
334 GiveSystemAudioMode = 0x7D,
335 ReportAudioStatus = 0x7A,
336 SetSystemAudioMode = 0x72,
337 SystemAudioModeRequest = 0x70,
338 SystemAudioModeStatus = 0x7E,
339 SetAudioRate = 0x9A,
340 /* when this opcode is set, no opcode will be sent to the device. this is one of the reserved numbers */
341 None = 0xFD
342 };
343
344 public enum class CecSystemAudioStatus
345 {
346 Off = 0,
347 On = 1
348 };
349
350 public enum class CecClientVersion
351 {
352 VersionPre1_5 = 0,
353 Version1_5_0 = 0x1500,
354 Version1_5_1 = 0x1501,
355 Version1_5_2 = 0x1502,
356 Version1_5_3 = 0x1503,
357 Version1_6_0 = 0x1600,
358 Version1_6_1 = 0x1601,
359 Version1_6_2 = 0x1602,
360 Version1_6_3 = 0x1603
361 };
362
363 public enum class CecServerVersion
364 {
365 VersionPre1_5 = 0,
366 Version1_5_0 = 0x1500,
367 Version1_5_1 = 0x1501,
368 Version1_5_2 = 0x1502,
369 Version1_5_3 = 0x1503,
370 Version1_6_0 = 0x1600,
371 Version1_6_1 = 0x1601,
372 Version1_6_2 = 0x1602,
373 Version1_6_3 = 0x1603
374 };
375
376 public ref class CecAdapter
377 {
378 public:
379 CecAdapter(System::String ^ strPath, System::String ^ strComPort)
380 {
381 Path = strPath;
382 ComPort = strComPort;
383 }
384
385 property System::String ^ Path;
386 property System::String ^ ComPort;
387 };
388
389 public ref class CecDeviceTypeList
390 {
391 public:
392 CecDeviceTypeList(void)
393 {
394 Types = gcnew array<CecDeviceType>(5);
395 for (unsigned int iPtr = 0; iPtr < 5; iPtr++)
396 Types[iPtr] = CecDeviceType::Reserved;
397 }
398
399 property array<CecDeviceType> ^ Types;
400 };
401
402 public ref class CecLogicalAddresses
403 {
404 public:
405 CecLogicalAddresses(void)
406 {
407 Addresses = gcnew array<CecLogicalAddress>(16);
408 Clear();
409 }
410
411 void Clear(void)
412 {
413 for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
414 Addresses[iPtr] = CecLogicalAddress::Unknown;
415 }
416
417 bool IsSet(CecLogicalAddress iAddress)
418 {
419 return Addresses[(unsigned int)iAddress] != CecLogicalAddress::Unknown;
420 }
421
422 void Set(CecLogicalAddress iAddress)
423 {
424 Addresses[(unsigned int)iAddress] = iAddress;
425 }
426
427 property CecLogicalAddress Primary;
428 property array<CecLogicalAddress> ^ Addresses;
429 };
430
431 public ref class CecDatapacket
432 {
433 public:
434 CecDatapacket(void)
435 {
436 Data = gcnew array<uint8_t>(100);
437 Size = 0;
438 }
439
440 void PushBack(uint8_t data)
441 {
442 if (Size < 100)
443 {
444 Data[Size] = data;
445 Size++;
446 }
447 }
448
449 property array<uint8_t> ^ Data;
450 property uint8_t Size;
451 };
452
453 public ref class CecCommand
454 {
455 public:
456 CecCommand(CecLogicalAddress iInitiator, CecLogicalAddress iDestination, bool bAck, bool bEom, CecOpcode iOpcode, int32_t iTransmitTimeout)
457 {
458 Initiator = iInitiator;
459 Destination = iDestination;
460 Ack = bAck;
461 Eom = bEom;
462 Opcode = iOpcode;
463 OpcodeSet = true;
464 TransmitTimeout = iTransmitTimeout;
465 Parameters = gcnew CecDatapacket;
466 Empty = false;
467 }
468
469 CecCommand(void)
470 {
471 Initiator = CecLogicalAddress::Unknown;
472 Destination = CecLogicalAddress::Unknown;
473 Ack = false;
474 Eom = false;
475 Opcode = CecOpcode::None;
476 OpcodeSet = false;
477 TransmitTimeout = 0;
478 Parameters = gcnew CecDatapacket;
479 Empty = true;
480 }
481
482 void PushBack(uint8_t data)
483 {
484 if (Initiator == CecLogicalAddress::Unknown && Destination == CecLogicalAddress::Unknown)
485 {
486 Initiator = (CecLogicalAddress) (data >> 4);
487 Destination = (CecLogicalAddress) (data & 0xF);
488 }
489 else if (!OpcodeSet)
490 {
491 OpcodeSet = true;
492 Opcode = (CecOpcode)data;
493 }
494 else
495 {
496 Parameters->PushBack(data);
497 }
498 }
499
500 property bool Empty;
501 property CecLogicalAddress Initiator;
502 property CecLogicalAddress Destination;
503 property bool Ack;
504 property bool Eom;
505 property CecOpcode Opcode;
506 property CecDatapacket ^ Parameters;
507 property bool OpcodeSet;
508 property int32_t TransmitTimeout;
509 };
510
511 public ref class CecKeypress
512 {
513 public:
514 CecKeypress(CecUserControlCode iKeycode, unsigned int iDuration)
515 {
516 Keycode = iKeycode;
517 Duration = iDuration;
518 Empty = false;
519 }
520
521 CecKeypress(void)
522 {
523 Keycode = CecUserControlCode::Unknown;
524 Duration = 0;
525 Empty = true;
526 }
527
528 property bool Empty;
529 property CecUserControlCode Keycode;
530 property unsigned int Duration;
531 };
532
533 public ref class CecLogMessage
534 {
535 public:
536 CecLogMessage(System::String ^ strMessage, CecLogLevel iLevel, int64_t iTime)
537 {
538 Message = strMessage;
539 Level = iLevel;
540 Time = iTime;
541 Empty = false;
542 }
543
544 CecLogMessage(void)
545 {
546 Message = "";
547 Level = CecLogLevel::None;
548 Time = 0;
549 Empty = true;
550 }
551
552 property bool Empty;
553 property System::String ^Message;
554 property CecLogLevel Level;
555 property int64_t Time;
556 };
557
558 ref class CecCallbackMethods; //forward
559 public ref class LibCECConfiguration
560 {
561 public:
562 LibCECConfiguration(void)
563 {
564 DeviceName = "";
565 DeviceTypes = gcnew CecDeviceTypeList();
566 AutodetectAddress = true;
567 PhysicalAddress = CEC_DEFAULT_PHYSICAL_ADDRESS;
568 BaseDevice = (CecLogicalAddress)CEC_DEFAULT_BASE_DEVICE;
569 HDMIPort = CEC_DEFAULT_HDMI_PORT;
570 ClientVersion = CecClientVersion::VersionPre1_5;
571 ServerVersion = CecServerVersion::VersionPre1_5;
572 TvVendor = CecVendorId::Unknown;
573
574 GetSettingsFromROM = false;
575 UseTVMenuLanguage = CEC_DEFAULT_SETTING_USE_TV_MENU_LANGUAGE == 1;
576 ActivateSource = CEC_DEFAULT_SETTING_ACTIVATE_SOURCE == 1;
577
578 WakeDevices = gcnew CecLogicalAddresses();
579 if (CEC_DEFAULT_SETTING_ACTIVATE_SOURCE == 1)
580 WakeDevices->Set(CecLogicalAddress::Tv);
581
582 PowerOffDevices = gcnew CecLogicalAddresses();
583 if (CEC_DEFAULT_SETTING_POWER_OFF_SHUTDOWN == 1)
584 PowerOffDevices->Set(CecLogicalAddress::Broadcast);
585
586 PowerOffScreensaver = CEC_DEFAULT_SETTING_POWER_OFF_SCREENSAVER == 1;
587 PowerOffOnStandby = CEC_DEFAULT_SETTING_POWER_OFF_ON_STANDBY == 1;
588
589 SendInactiveSource = CEC_DEFAULT_SETTING_SEND_INACTIVE_SOURCE == 1;
590 LogicalAddresses = gcnew CecLogicalAddresses();
591 FirmwareVersion = 1;
592 PowerOffDevicesOnStandby = CEC_DEFAULT_SETTING_POWER_OFF_DEVICES_STANDBY == 1;
593 ShutdownOnStandby = CEC_DEFAULT_SETTING_SHUTDOWN_ON_STANDBY == 1;
594 DeviceLanguage = "";
595 }
596
597 void SetCallbacks(CecCallbackMethods ^callbacks)
598 {
599 Callbacks = callbacks;
600 }
601
602 void Update(const CEC::libcec_configuration &config)
603 {
604 DeviceName = gcnew System::String(config.strDeviceName);
605
606 for (unsigned int iPtr = 0; iPtr < 5; iPtr++)
607 DeviceTypes->Types[iPtr] = (CecDeviceType)config.deviceTypes.types[iPtr];
608
609 AutodetectAddress = config.bAutodetectAddress == 1;
610 PhysicalAddress = config.iPhysicalAddress;
611 BaseDevice = (CecLogicalAddress)config.baseDevice;
612 HDMIPort = config.iHDMIPort;
613 ClientVersion = (CecClientVersion)config.clientVersion;
614 ServerVersion = (CecServerVersion)config.serverVersion;
615 TvVendor = (CecVendorId)config.tvVendor;
616
617 // player specific settings
618 GetSettingsFromROM = config.bGetSettingsFromROM == 1;
619 UseTVMenuLanguage = config.bUseTVMenuLanguage == 1;
620 ActivateSource = config.bActivateSource == 1;
621
622 WakeDevices->Clear();
623 for (uint8_t iPtr = 0; iPtr <= 16; iPtr++)
624 if (config.wakeDevices[iPtr])
625 WakeDevices->Set((CecLogicalAddress)iPtr);
626
627 PowerOffDevices->Clear();
628 for (uint8_t iPtr = 0; iPtr <= 16; iPtr++)
629 if (config.powerOffDevices[iPtr])
630 PowerOffDevices->Set((CecLogicalAddress)iPtr);
631
632 PowerOffScreensaver = config.bPowerOffScreensaver == 1;
633 PowerOffOnStandby = config.bPowerOffOnStandby == 1;
634
635 if (ServerVersion >= CecServerVersion::Version1_5_1)
636 SendInactiveSource = config.bSendInactiveSource == 1;
637
638 if (ServerVersion >= CecServerVersion::Version1_5_3)
639 {
640 LogicalAddresses->Clear();
641 for (uint8_t iPtr = 0; iPtr <= 16; iPtr++)
642 if (config.logicalAddresses[iPtr])
643 LogicalAddresses->Set((CecLogicalAddress)iPtr);
644 }
645
646 if (ServerVersion >= CecServerVersion::Version1_6_0)
647 {
648 FirmwareVersion = config.iFirmwareVersion;
649 PowerOffDevicesOnStandby = config.bPowerOffDevicesOnStandby == 1;
650 ShutdownOnStandby = config.bShutdownOnStandby == 1;
651 }
652
653 if (ServerVersion >= CecServerVersion::Version1_6_2)
654 DeviceLanguage = gcnew System::String(config.strDeviceLanguage);
655
656 if (ServerVersion >= CecServerVersion::Version1_6_3)
657 MonitorOnlyClient = config.bMonitorOnly == 1;
658 }
659
660 property System::String ^ DeviceName;
661 property CecDeviceTypeList ^ DeviceTypes;
662 property bool AutodetectAddress;
663 property uint16_t PhysicalAddress;
664 property CecLogicalAddress BaseDevice;
665 property uint8_t HDMIPort;
666 property CecClientVersion ClientVersion;
667 property CecServerVersion ServerVersion;
668 property CecVendorId TvVendor;
669
670 // player specific settings
671 property bool GetSettingsFromROM;
672 property bool UseTVMenuLanguage;
673 property bool ActivateSource;
674 property CecLogicalAddresses ^WakeDevices;
675 property CecLogicalAddresses ^PowerOffDevices;
676 property bool PowerOffScreensaver;
677 property bool PowerOffOnStandby;
678 property bool SendInactiveSource;
679 property CecLogicalAddresses ^LogicalAddresses;
680 property uint16_t FirmwareVersion;
681 property bool PowerOffDevicesOnStandby;
682 property bool ShutdownOnStandby;
683 property bool MonitorOnlyClient;
684 property System::String ^ DeviceLanguage;
685 property CecCallbackMethods ^ Callbacks;
686 };
687
688 // the callback methods are called by unmanaged code, so we need some delegates for this
689 #pragma unmanaged
690 // unmanaged callback methods
691 typedef int (__stdcall *LOGCB) (const CEC::cec_log_message &message);
692 typedef int (__stdcall *KEYCB) (const CEC::cec_keypress &key);
693 typedef int (__stdcall *COMMANDCB)(const CEC::cec_command &command);
694 typedef int (__stdcall *CONFIGCB) (const CEC::libcec_configuration &config);
695 typedef int (__stdcall *ALERTCB) (const CEC::libcec_alert, const CEC::libcec_parameter &data);
696 typedef int (__stdcall *MENUCB) (const CEC::cec_menu_state newVal);
697
698 static LOGCB g_logCB;
699 static KEYCB g_keyCB;
700 static COMMANDCB g_commandCB;
701 static CONFIGCB g_configCB;
702 static ALERTCB g_alertCB;
703 static MENUCB g_menuCB;
704 static CEC::ICECCallbacks g_cecCallbacks;
705
706 int CecLogMessageCB(void *cbParam, const CEC::cec_log_message &message)
707 {
708 if (g_logCB)
709 return g_logCB(message);
710 return 0;
711 }
712
713 int CecKeyPressCB(void *cbParam, const CEC::cec_keypress &key)
714 {
715 if (g_keyCB)
716 return g_keyCB(key);
717 return 0;
718 }
719
720 int CecCommandCB(void *cbParam, const CEC::cec_command &command)
721 {
722 if (g_commandCB)
723 return g_commandCB(command);
724 return 0;
725 }
726
727 int CecConfigCB(void *cbParam, const CEC::libcec_configuration &config)
728 {
729 if (g_configCB)
730 return g_configCB(config);
731 return 0;
732 }
733
734 int CecAlertCB(void *cbParam, const CEC::libcec_alert alert, const CEC::libcec_parameter &data)
735 {
736 if (g_alertCB)
737 return g_alertCB(alert, data);
738 return 0;
739 }
740
741 int CecMenuCB(void *cbParam, const CEC::cec_menu_state newVal)
742 {
743 if (g_menuCB)
744 return g_menuCB(newVal);
745 return 0;
746 }
747
748 #pragma managed
749 // delegates for the unmanaged callback methods
750 public delegate int CecLogMessageManagedDelegate(const CEC::cec_log_message &);
751 public delegate int CecKeyPressManagedDelegate(const CEC::cec_keypress &);
752 public delegate int CecCommandManagedDelegate(const CEC::cec_command &);
753 public delegate int CecConfigManagedDelegate(const CEC::libcec_configuration &);
754 public delegate int CecAlertManagedDelegate(const CEC::libcec_alert, const CEC::libcec_parameter &);
755 public delegate int CecMenuManagedDelegate(const CEC::cec_menu_state newVal);
756
757 // callback method interface
758 public ref class CecCallbackMethods
759 {
760 public:
761 CecCallbackMethods(void)
762 {
763 m_bHasCallbacks = false;
764 m_bDelegatesCreated = false;
765 }
766
767 ~CecCallbackMethods(void)
768 {
769 DestroyDelegates();
770 }
771
772 protected:
773 !CecCallbackMethods(void)
774 {
775 DestroyDelegates();
776 }
777
778 public:
779 virtual void DisableCallbacks(void)
780 {
781 DestroyDelegates();
782 }
783
784 virtual bool EnableCallbacks(CecCallbackMethods ^ callbacks)
785 {
786 CreateDelegates();
787 if (!m_bHasCallbacks)
788 {
789 m_bHasCallbacks = true;
790 m_callbacks = callbacks;
791 return true;
792 }
793
794 return false;
795 }
796
797 virtual int ReceiveLogMessage(CecLogMessage ^ message)
798 {
799 return 0;
800 }
801
802 virtual int ReceiveKeypress(CecKeypress ^ key)
803 {
804 return 0;
805 }
806
807 virtual int ReceiveCommand(CecCommand ^ command)
808 {
809 return 0;
810 }
811
812 virtual int ConfigurationChanged(LibCECConfiguration ^ config)
813 {
814 return 0;
815 }
816
817 virtual int ReceiveAlert(CecAlert alert, CecParameter ^ data)
818 {
819 return 0;
820 }
821
822 virtual int ReceiveMenuStateChange(CecMenuState newVal)
823 {
824 return 0;
825 }
826
827 protected:
828 // managed callback methods
829 int CecLogMessageManaged(const CEC::cec_log_message &message)
830 {
831 int iReturn(0);
832 if (m_bHasCallbacks)
833 iReturn = m_callbacks->ReceiveLogMessage(gcnew CecLogMessage(gcnew System::String(message.message), (CecLogLevel)message.level, message.time));
834 return iReturn;
835 }
836
837 int CecKeyPressManaged(const CEC::cec_keypress &key)
838 {
839 int iReturn(0);
840 if (m_bHasCallbacks)
841 iReturn = m_callbacks->ReceiveKeypress(gcnew CecKeypress((CecUserControlCode)key.keycode, key.duration));
842 return iReturn;
843 }
844
845 int CecCommandManaged(const CEC::cec_command &command)
846 {
847 int iReturn(0);
848 if (m_bHasCallbacks)
849 {
850 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);
851 for (uint8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
852 newCommand->Parameters->PushBack(command.parameters[iPtr]);
853 iReturn = m_callbacks->ReceiveCommand(newCommand);
854 }
855 return iReturn;
856 }
857
858 int CecConfigManaged(const CEC::libcec_configuration &config)
859 {
860 int iReturn(0);
861 if (m_bHasCallbacks)
862 {
863 LibCECConfiguration ^netConfig = gcnew LibCECConfiguration();
864 netConfig->Update(config);
865 iReturn = m_callbacks->ConfigurationChanged(netConfig);
866 }
867 return iReturn;
868 }
869
870 int CecAlertManaged(const CEC::libcec_alert alert, const CEC::libcec_parameter &data)
871 {
872 int iReturn(0);
873 if (m_bHasCallbacks)
874 {
875 CecParameterType newType = (CecParameterType)data.paramType;
876 if (newType == CecParameterType::ParameterTypeString)
877 {
878 System::String ^ newData = gcnew System::String((const char *)data.paramData, 0, 128);
879 CecParameter ^ newParam = gcnew CecParameter(newType, newData);
880 iReturn = m_callbacks->ReceiveAlert((CecAlert)alert, newParam);
881 }
882 }
883 return iReturn;
884 }
885
886 int CecMenuManaged(const CEC::cec_menu_state newVal)
887 {
888 int iReturn(0);
889 if (m_bHasCallbacks)
890 {
891 iReturn = m_callbacks->ReceiveMenuStateChange((CecMenuState)newVal);
892 }
893 return iReturn;
894 }
895
896 void DestroyDelegates()
897 {
898 m_bHasCallbacks = false;
899 if (m_bDelegatesCreated)
900 {
901 m_bDelegatesCreated = false;
902 m_logMessageGCHandle.Free();
903 m_keypressGCHandle.Free();
904 m_commandGCHandle.Free();
905 m_alertGCHandle.Free();
906 m_menuGCHandle.Free();
907 }
908 }
909
910 void CreateDelegates()
911 {
912 DestroyDelegates();
913
914 if (!m_bDelegatesCreated)
915 {
916 msclr::interop::marshal_context ^ context = gcnew msclr::interop::marshal_context();
917
918 // create the delegate method for the log message callback
919 m_logMessageDelegate = gcnew CecLogMessageManagedDelegate(this, &CecCallbackMethods::CecLogMessageManaged);
920 m_logMessageGCHandle = System::Runtime::InteropServices::GCHandle::Alloc(m_logMessageDelegate);
921 g_logCB = static_cast<LOGCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_logMessageDelegate).ToPointer());
922 g_cecCallbacks.CBCecLogMessage = CecLogMessageCB;
923
924 // create the delegate method for the keypress callback
925 m_keypressDelegate = gcnew CecKeyPressManagedDelegate(this, &CecCallbackMethods::CecKeyPressManaged);
926 m_keypressGCHandle = System::Runtime::InteropServices::GCHandle::Alloc(m_keypressDelegate);
927 g_keyCB = static_cast<KEYCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_keypressDelegate).ToPointer());
928 g_cecCallbacks.CBCecKeyPress = CecKeyPressCB;
929
930 // create the delegate method for the command callback
931 m_commandDelegate = gcnew CecCommandManagedDelegate(this, &CecCallbackMethods::CecCommandManaged);
932 m_commandGCHandle = System::Runtime::InteropServices::GCHandle::Alloc(m_commandDelegate);
933 g_commandCB = static_cast<COMMANDCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_commandDelegate).ToPointer());
934 g_cecCallbacks.CBCecCommand = CecCommandCB;
935
936 // create the delegate method for the configuration change callback
937 m_configDelegate = gcnew CecConfigManagedDelegate(this, &CecCallbackMethods::CecConfigManaged);
938 m_configGCHandle = System::Runtime::InteropServices::GCHandle::Alloc(m_configDelegate);
939 g_configCB = static_cast<CONFIGCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_configDelegate).ToPointer());
940 g_cecCallbacks.CBCecConfigurationChanged = CecConfigCB;
941
942 // create the delegate method for the alert callback
943 m_alertDelegate = gcnew CecAlertManagedDelegate(this, &CecCallbackMethods::CecAlertManaged);
944 m_alertGCHandle = System::Runtime::InteropServices::GCHandle::Alloc(m_alertDelegate);
945 g_alertCB = static_cast<ALERTCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_alertDelegate).ToPointer());
946 g_cecCallbacks.CBCecAlert = CecAlertCB;
947
948 // create the delegate method for the menu callback
949 m_menuDelegate = gcnew CecMenuManagedDelegate(this, &CecCallbackMethods::CecMenuManaged);
950 m_menuGCHandle = System::Runtime::InteropServices::GCHandle::Alloc(m_menuDelegate);
951 g_menuCB = static_cast<MENUCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_menuDelegate).ToPointer());
952 g_cecCallbacks.CBCecMenuStateChanged = CecMenuCB;
953
954 delete context;
955 m_bDelegatesCreated = true;
956 }
957 }
958
959 CecLogMessageManagedDelegate ^ m_logMessageDelegate;
960 static System::Runtime::InteropServices::GCHandle m_logMessageGCHandle;
961 LOGCB m_logMessageCallback;
962
963 CecKeyPressManagedDelegate ^ m_keypressDelegate;
964 static System::Runtime::InteropServices::GCHandle m_keypressGCHandle;
965 KEYCB m_keypressCallback;
966
967 CecCommandManagedDelegate ^ m_commandDelegate;
968 static System::Runtime::InteropServices::GCHandle m_commandGCHandle;
969 COMMANDCB m_commandCallback;
970
971 CecConfigManagedDelegate ^ m_configDelegate;
972 static System::Runtime::InteropServices::GCHandle m_configGCHandle;
973 CONFIGCB m_configCallback;
974
975 CecAlertManagedDelegate ^ m_alertDelegate;
976 static System::Runtime::InteropServices::GCHandle m_alertGCHandle;
977 CONFIGCB m_alertCallback;
978
979 CecMenuManagedDelegate ^ m_menuDelegate;
980 static System::Runtime::InteropServices::GCHandle m_menuGCHandle;
981 MENUCB m_menuCallback;
982
983 CecCallbackMethods ^ m_callbacks;
984 bool m_bHasCallbacks;
985 bool m_bDelegatesCreated;
986 };
987 }
libcec Piment Noir Debian package repository