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 CecPowerStatus
  87         {
  88                 On                      = 0x00,
  89                 Standby                 = 0x01,
  90                 InTransitionStandbyToOn = 0x02,
  91                 InTransitionOnToStandby = 0x03,
  92                 Unknown                 = 0x99
  93         };
  94
  95         public enum class CecVersion
  96         {
  97                 Unknown = 0x00,
  98                 V1_2    = 0x01,
  99                 V1_2A   = 0x02,
 100                 V1_3    = 0x03,
 101                 V1_3A   = 0x04,
 102                 V1_4    = 0x05
 103         };
 104
 105         public enum class CecDisplayControl
 106         {
 107                 DisplayForDefaultTime = 0x00,
 108                 DisplayUntilCleared   = 0x40,
 109                 ClearPreviousMessage  = 0x80,
 110                 ReservedForFutureUse  = 0xC0
 111         };
 112
 113         public enum class CecMenuState
 114         {
 115                 Activated   = 0,
 116                 Deactivated = 1
 117         };
 118
 119         public enum class CecDeckControlMode
 120         {
 121                 SkipForwardWind   = 1,
 122                 SkipReverseRewind = 2,
 123                 Stop              = 3,
 124                 Eject             = 4
 125         };
 126
 127         public enum class CecDeckInfo
 128         {
 129                 Play               = 0x11,
 130                 Record             = 0x12,
 131                 Reverse            = 0x13,
 132                 Still              = 0x14,
 133                 Slow               = 0x15,
 134                 SlowReverse        = 0x16,
 135                 FastForward        = 0x17,
 136                 FastReverse        = 0x18,
 137                 NoMedia            = 0x19,
 138                 Stop               = 0x1A,
 139                 SkipForwardWind    = 0x1B,
 140                 SkipReverseRewind  = 0x1C,
 141                 IndexSearchForward = 0x1D,
 142                 IndexSearchReverse = 0x1E,
 143                 OtherStatus        = 0x1F
 144         };
 145
 146         public enum class CecUserControlCode
 147         {
 148                 Select                      = 0x00,
 149                 Up                          = 0x01,
 150                 Down                        = 0x02,
 151                 Left                        = 0x03,
 152                 Right                       = 0x04,
 153                 RightUp                     = 0x05,
 154                 RightDown                   = 0x06,
 155                 LeftUp                      = 0x07,
 156                 LeftDown                    = 0x08,
 157                 RootMenu                    = 0x09,
 158                 SetupMenu                   = 0x0A,
 159                 ContentsMenu                = 0x0B,
 160                 FavoriteMenu                = 0x0C,
 161                 Exit                        = 0x0D,
 162                 Number0                     = 0x20,
 163                 Number1                     = 0x21,
 164                 Number2                     = 0x22,
 165                 Number3                     = 0x23,
 166                 Number4                     = 0x24,
 167                 Number5                     = 0x25,
 168                 Number6                     = 0x26,
 169                 Number7                     = 0x27,
 170                 Number8                     = 0x28,
 171                 Number9                     = 0x29,
 172                 Dot                         = 0x2A,
 173                 Enter                       = 0x2B,
 174                 Clear                       = 0x2C,
 175                 NextFavorite                = 0x2F,
 176                 ChannelUp                   = 0x30,
 177                 ChannelDown                 = 0x31,
 178                 PreviousChannel             = 0x32,
 179                 SoundSelect                 = 0x33,
 180                 InputSelect                 = 0x34,
 181                 DisplayInformation          = 0x35,
 182                 Help                        = 0x36,
 183                 PageUp                      = 0x37,
 184                 PageDown                    = 0x38,
 185                 Power                       = 0x40,
 186                 VolumeUp                    = 0x41,
 187                 VolumeDown                  = 0x42,
 188                 Mute                        = 0x43,
 189                 Play                        = 0x44,
 190                 Stop                        = 0x45,
 191                 Pause                       = 0x46,
 192                 Record                      = 0x47,
 193                 Rewind                      = 0x48,
 194                 FastForward                 = 0x49,
 195                 Eject                       = 0x4A,
 196                 Forward                     = 0x4B,
 197                 Backward                    = 0x4C,
 198                 StopRecord                  = 0x4D,
 199                 PauseRecord                 = 0x4E,
 200                 Angle                       = 0x50,
 201                 SubPicture                  = 0x51,
 202                 VideoOnDemand               = 0x52,
 203                 ElectronicProgramGuide      = 0x53,
 204                 TimerProgramming            = 0x54,
 205                 InitialConfiguration        = 0x55,
 206                 PlayFunction                = 0x60,
 207                 PausePlayFunction           = 0x61,
 208                 RecordFunction              = 0x62,
 209                 PauseRecordFunction         = 0x63,
 210                 StopFunction                = 0x64,
 211                 MuteFunction                = 0x65,
 212                 RestoreVolumeFunction       = 0x66,
 213                 TuneFunction                = 0x67,
 214                 SelectMediaFunction         = 0x68,
 215                 SelectAVInputFunction       = 0x69,
 216                 SelectAudioInputFunction    = 0x6A,
 217                 PowerToggleFunction         = 0x6B,
 218                 PowerOffFunction            = 0x6C,
 219                 PowerOnFunction             = 0x6D,
 220                 F1Blue                      = 0x71,
 221                 F2Red                       = 0X72,
 222                 F3Green                     = 0x73,
 223                 F4Yellow                    = 0x74,
 224                 F5                          = 0x75,
 225                 Data                        = 0x76,
 226                 Max                         = 0x76,
 227                 Unknown
 228         };
 229
 230         public enum class CecVendorId
 231         {
 232                 Samsung   = 0x00F0,
 233                 LG        = 0xE091,
 234                 Panasonic = 0x8045,
 235                 Pioneer   = 0xE036,
 236                 Onkyo     = 0x09B0,
 237                 Yamaha    = 0xA0DE,
 238                 Philips   = 0x903E,
 239                 Sony      = 0x080046,
 240                 Unknown   = 0
 241         };
 242
 243         public enum class CecAudioStatus
 244         {
 245                 MuteStatusMask      = 0x80,
 246                 VolumeStatusMask    = 0x7F,
 247                 VolumeMin           = 0x00,
 248                 VolumeMax           = 0x64,
 249                 VolumeStatusUnknown = 0x7F
 250         };
 251
 252         public enum class CecOpcode
 253         {
 254                 ActiveSource                  = 0x82,
 255                 ImageViewOn                   = 0x04,
 256                 TextViewOn                    = 0x0D,
 257                 InactiveSource                = 0x9D,
 258                 RequestActiveSource           = 0x85,
 259                 RoutingChange                 = 0x80,
 260                 RoutingInformation            = 0x81,
 261                 SetStreamPath                 = 0x86,
 262                 Standby                       = 0x36,
 263                 RecordOff                     = 0x0B,
 264                 RecordOn                      = 0x09,
 265                 RecordStatus                  = 0x0A,
 266                 RecordTvScreen                = 0x0F,
 267                 ClearAnalogueTimer            = 0x33,
 268                 ClearDigitalTimer             = 0x99,
 269                 ClearExternalTimer            = 0xA1,
 270                 SetAnalogueTimer              = 0x34,
 271                 SetDigitalTimer               = 0x97,
 272                 SetExternalTimer              = 0xA2,
 273                 SetTimerProgramTitle          = 0x67,
 274                 TimerClearedStatus            = 0x43,
 275                 TimerStatus                   = 0x35,
 276                 CecVersion                    = 0x9E,
 277                 GetCecVersion                 = 0x9F,
 278                 GivePhysicalAddress           = 0x83,
 279                 GetMenuLanguage               = 0x91,
 280                 ReportPhysicalAddress         = 0x84,
 281                 SetMenuLanguage               = 0x32,
 282                 DeckControl                   = 0x42,
 283                 DeckStatus                    = 0x1B,
 284                 GiveDeckStatus                = 0x1A,
 285                 Play                          = 0x41,
 286                 GiveTunerDeviceStatus         = 0x08,
 287                 SelectAnalogueService         = 0x92,
 288                 SelectDigtalService           = 0x93,
 289                 TunerDeviceStatus             = 0x07,
 290                 TunerStepDecrement            = 0x06,
 291                 TunerStepIncrement            = 0x05,
 292                 DeviceVendorId                = 0x87,
 293                 GiveDeviceVendorId            = 0x8C,
 294                 VendorCommand                 = 0x89,
 295                 VendorCommandWithId           = 0xA0,
 296                 VendorRemoteButtonDown        = 0x8A,
 297                 VendorRemoteButtonUp          = 0x8B,
 298                 SetOsdString                  = 0x64,
 299                 GiveOsdName                   = 0x46,
 300                 SetOsdName                    = 0x47,
 301                 MenuRequest                   = 0x8D,
 302                 MenuStatus                    = 0x8E,
 303                 UserControlPressed            = 0x44,
 304                 UserControlRelease            = 0x45,
 305                 GiveDevicePowerStatus         = 0x8F,
 306                 ReportPowerStatus             = 0x90,
 307                 FeatureAbort                  = 0x00,
 308                 Abort                         = 0xFF,
 309                 GiveAudioStatus               = 0x71,
 310                 GiveSystemAudioMode           = 0x7D,
 311                 ReportAudioStatus             = 0x7A,
 312                 SetSystemAudioMode            = 0x72,
 313                 SystemAudioModeRequest        = 0x70,
 314                 SystemAudioModeStatus         = 0x7E,
 315                 SetAudioRate                  = 0x9A,
 316                 /* when this opcode is set, no opcode will be sent to the device. this is one of the reserved numbers */
 317                 None                          = 0xFD
 318         };
 319
 320         public enum class CecSystemAudioStatus
 321         {
 322                 Off = 0,
 323                 On  = 1
 324         };
 325
 326         public enum class CecClientVersion
 327         {
 328                 VersionPre1_5 = 0,
 329                 Version1_5_0  = 0x1500
 330         };
 331
 332         public ref class CecAdapter
 333         {
 334         public:
 335                 CecAdapter(System::String ^ strPath, System::String ^ strComPort)
 336                 {
 337                         Path = strPath;
 338                         ComPort = strComPort;
 339                 }
 340
 341                 property System::String ^ Path;
 342                 property System::String ^ ComPort;
 343         };
 344
 345         public ref class CecDeviceTypeList
 346         {
 347         public:
 348                 CecDeviceTypeList(void)
 349                 {
 350                         Types = gcnew array<CecDeviceType>(5);
 351                         for (unsigned int iPtr = 0; iPtr < 5; iPtr++)
 352                                 Types[iPtr] = CecDeviceType::Reserved;
 353                 }
 354
 355                 property array<CecDeviceType> ^ Types;
 356         };
 357
 358         public ref class CecLogicalAddresses
 359         {
 360         public:
 361                 CecLogicalAddresses(void)
 362                 {
 363                         Addresses = gcnew array<CecLogicalAddress>(16);
 364                         Clear();
 365                 }
 366
 367                 void Clear(void)
 368                 {
 369                         for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
 370                                 Addresses[iPtr] = CecLogicalAddress::Unknown;
 371                 }
 372
 373                 bool IsSet(CecLogicalAddress iAddress)
 374                 {
 375                         return Addresses[(unsigned int)iAddress] != CecLogicalAddress::Unknown;
 376                 }
 377
 378           void Set(CecLogicalAddress iAddress)
 379                 {
 380                         Addresses[(unsigned int)iAddress] = iAddress;
 381                 }
 382
 383                 property CecLogicalAddress          Primary;
 384                 property array<CecLogicalAddress> ^ Addresses;
 385         };
 386
 387         public ref class CecDatapacket
 388         {
 389         public:
 390                 CecDatapacket(void)
 391                 {
 392                         Data = gcnew array<uint8_t>(100);
 393                         Size = 0;
 394                 }
 395
 396                 void PushBack(uint8_t data)
 397                 {
 398                         if (Size < 100)
 399                         {
 400                                 Data[Size] = data;
 401                                 Size++;
 402                         }
 403                 }
 404
 405                 property array<uint8_t> ^ Data;
 406                 property uint8_t          Size;
 407         };
 408
 409         public ref class CecCommand
 410         {
 411         public:
 412                 CecCommand(CecLogicalAddress iInitiator, CecLogicalAddress iDestination, bool bAck, bool bEom, CecOpcode iOpcode, int32_t iTransmitTimeout)
 413                 {
 414                         Initiator       = iInitiator;
 415                         Destination     = iDestination;
 416                         Ack             = bAck;
 417                         Eom             = bEom;
 418                         Opcode          = iOpcode;
 419                         OpcodeSet       = true;
 420                         TransmitTimeout = iTransmitTimeout;
 421                         Parameters      = gcnew CecDatapacket;
 422                         Empty           = false;
 423                 }
 424
 425                 CecCommand(void)
 426                 {
 427                         Initiator       = CecLogicalAddress::Unknown;
 428                         Destination     = CecLogicalAddress::Unknown;
 429                         Ack             = false;
 430                         Eom             = false;
 431                         Opcode          = CecOpcode::None;
 432                         OpcodeSet       = false;
 433                         TransmitTimeout = 0;
 434                         Parameters      = gcnew CecDatapacket;
 435                         Empty           = true;
 436                 }
 437
 438                 void PushBack(uint8_t data)
 439                 {
 440                         if (Initiator == CecLogicalAddress::Unknown && Destination == CecLogicalAddress::Unknown)
 441                         {
 442                                 Initiator   = (CecLogicalAddress) (data >> 4);
 443                                 Destination = (CecLogicalAddress) (data & 0xF);
 444                         }
 445                         else if (!OpcodeSet)
 446                         {
 447                                 OpcodeSet = true;
 448                                 Opcode    = (CecOpcode)data;
 449                         }
 450                         else
 451                         {
 452                                 Parameters->PushBack(data);
 453                         }
 454                 }
 455
 456                 property bool               Empty;
 457                 property CecLogicalAddress  Initiator;
 458                 property CecLogicalAddress  Destination;
 459                 property bool               Ack;
 460                 property bool               Eom;
 461                 property CecOpcode          Opcode;
 462                 property CecDatapacket ^    Parameters;
 463                 property bool               OpcodeSet;
 464                 property int32_t            TransmitTimeout;
 465         };
 466
 467         public ref class CecKeypress
 468         {
 469         public:
 470                 CecKeypress(int iKeycode, unsigned int iDuration)
 471                 {
 472                         Keycode  = iKeycode;
 473                         Duration = iDuration;
 474                         Empty    = false;
 475                 }
 476
 477                 CecKeypress(void)
 478                 {
 479                         Keycode  = 0;
 480                         Duration = 0;
 481                         Empty    = true;
 482                 }
 483
 484                 property bool         Empty;
 485                 property int          Keycode;
 486                 property unsigned int Duration;
 487         };
 488
 489         public ref class CecLogMessage
 490         {
 491         public:
 492                 CecLogMessage(System::String ^ strMessage, CecLogLevel iLevel, int64_t iTime)
 493                 {
 494                         Message = strMessage;
 495                         Level   = iLevel;
 496                         Time    = iTime;
 497                         Empty   = false;
 498                 }
 499
 500                 CecLogMessage(void)
 501                 {
 502                         Message = "";
 503                         Level   = CecLogLevel::None;
 504                         Time    = 0;
 505                         Empty   = true;
 506                 }
 507
 508                 property bool            Empty;
 509                 property System::String ^Message;
 510                 property CecLogLevel     Level;
 511                 property int64_t         Time;
 512         };
 513
 514         ref class CecCallbackMethods; //forward
 515         public ref class LibCECConfiguration
 516         {
 517         public:
 518                 LibCECConfiguration(void)
 519                 {
 520                         DeviceName          = "";
 521                         DeviceTypes         = gcnew CecDeviceTypeList();
 522                         AutodetectAddress  = true;
 523                         PhysicalAddress     = CEC_DEFAULT_PHYSICAL_ADDRESS;
 524                         BaseDevice          = (CecLogicalAddress)CEC_DEFAULT_BASE_DEVICE;
 525                         HDMIPort            = CEC_DEFAULT_HDMI_PORT;
 526                         ClientVersion       = CecClientVersion::VersionPre1_5;
 527                         TvVendor            = CecVendorId::Unknown;
 528
 529                         GetSettingsFromROM  = false;
 530                         UseTVMenuLanguage   = CEC_DEFAULT_SETTING_USE_TV_MENU_LANGUAGE == 1;
 531                         ActivateSource      = CEC_DEFAULT_SETTING_ACTIVATE_SOURCE == 1;
 532
 533                         WakeDevices         = gcnew CecLogicalAddresses();
 534                         if (CEC_DEFAULT_SETTING_ACTIVATE_SOURCE == 1)
 535                                 WakeDevices->Set(CecLogicalAddress::Tv);
 536
 537                         PowerOffDevices     = gcnew CecLogicalAddresses();
 538                         if (CEC_DEFAULT_SETTING_POWER_OFF_SHUTDOWN == 1)
 539                                 PowerOffDevices->Set(CecLogicalAddress::Broadcast);
 540
 541                         PowerOffScreensaver = CEC_DEFAULT_SETTING_POWER_OFF_SCREENSAVER == 1;
 542                         PowerOffOnStandby   = CEC_DEFAULT_SETTING_POWER_OFF_ON_STANDBY == 1;
 543                 }
 544
 545                 void SetCallbacks(CecCallbackMethods ^callbacks)
 546                 {
 547                         Callbacks = callbacks;
 548                 }
 549
 550                 property System::String ^     DeviceName;
 551                 property CecDeviceTypeList ^  DeviceTypes;
 552                 property bool                 AutodetectAddress;
 553                 property uint16_t             PhysicalAddress;
 554                 property CecLogicalAddress    BaseDevice;
 555                 property uint8_t              HDMIPort;
 556                 property CecClientVersion     ClientVersion;
 557                 property CecVendorId          TvVendor;
 558
 559                 // player specific settings
 560                 property bool                 GetSettingsFromROM;
 561                 property bool                 UseTVMenuLanguage;
 562                 property bool                 ActivateSource;
 563                 property CecLogicalAddresses ^WakeDevices;
 564                 property CecLogicalAddresses ^PowerOffDevices;
 565                 property bool                 PowerOffScreensaver;
 566                 property bool                 PowerOffOnStandby;
 567
 568                 property CecCallbackMethods ^ Callbacks;
 569         };
 570
 571         // the callback methods are called by unmanaged code, so we need some delegates for this
 572         #pragma unmanaged
 573         // unmanaged callback methods
 574         typedef int (__stdcall *LOGCB)    (const CEC::cec_log_message &message);
 575         typedef int (__stdcall *KEYCB)    (const CEC::cec_keypress &key);
 576         typedef int (__stdcall *COMMANDCB)(const CEC::cec_command &command);
 577         typedef int (__stdcall *CONFIGCB) (const CEC::libcec_configuration &config);
 578
 579         static LOGCB              g_logCB;
 580         static KEYCB              g_keyCB;
 581         static COMMANDCB          g_commandCB;
 582         static CONFIGCB           g_configCB;
 583         static CEC::ICECCallbacks g_cecCallbacks;
 584
 585         int CecLogMessageCB(void *cbParam, const CEC::cec_log_message &message)
 586         {
 587                 if (g_logCB)
 588                         return g_logCB(message);
 589                 return 0;
 590         }
 591
 592         int CecKeyPressCB(void *cbParam, const CEC::cec_keypress &key)
 593         {
 594                 if (g_keyCB)
 595                         return g_keyCB(key);
 596                 return 0;
 597         }
 598
 599         int CecCommandCB(void *cbParam, const CEC::cec_command &command)
 600         {
 601                 if (g_commandCB)
 602                         return g_commandCB(command);
 603                 return 0;
 604         }
 605
 606   int CecConfigCB(void *cbParam, const CEC::libcec_configuration &config)
 607         {
 608                 if (g_configCB)
 609                         return g_configCB(config);
 610                 return 0;
 611         }
 612
 613         #pragma managed
 614         // delegates for the unmanaged callback methods
 615         public delegate int CecLogMessageManagedDelegate(const CEC::cec_log_message &);
 616         public delegate int CecKeyPressManagedDelegate(const CEC::cec_keypress &);
 617         public delegate int CecCommandManagedDelegate(const CEC::cec_command &);
 618         public delegate int CecConfigManagedDelegate(const CEC::libcec_configuration &);
 619
 620         // callback method interface
 621         public ref class CecCallbackMethods
 622         {
 623         public:
 624                 CecCallbackMethods(void)
 625                 {
 626                         m_bHasCallbacks = false;
 627                         msclr::interop::marshal_context ^ context = gcnew msclr::interop::marshal_context();
 628
 629                         // create the delegate method for the log message callback
 630                         m_logMessageDelegate           = gcnew CecLogMessageManagedDelegate(this, &CecCallbackMethods::CecLogMessageManaged);
 631                         m_logMessageGCHandle           = System::Runtime::InteropServices::GCHandle::Alloc(m_logMessageDelegate);
 632                         g_logCB                        = static_cast<LOGCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_logMessageDelegate).ToPointer());
 633                         g_cecCallbacks.CBCecLogMessage = CecLogMessageCB;
 634
 635                         // create the delegate method for the keypress callback
 636                         m_keypressDelegate           = gcnew CecKeyPressManagedDelegate(this, &CecCallbackMethods::CecKeyPressManaged);
 637                         m_keypressGCHandle           = System::Runtime::InteropServices::GCHandle::Alloc(m_keypressDelegate);
 638                         g_keyCB                      = static_cast<KEYCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_keypressDelegate).ToPointer());
 639                         g_cecCallbacks.CBCecKeyPress = CecKeyPressCB;
 640
 641                         // create the delegate method for the command callback
 642                         m_commandDelegate           = gcnew CecCommandManagedDelegate(this, &CecCallbackMethods::CecCommandManaged);
 643                         m_commandGCHandle           = System::Runtime::InteropServices::GCHandle::Alloc(m_commandDelegate);
 644                         g_commandCB                 = static_cast<COMMANDCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_commandDelegate).ToPointer());
 645                         g_cecCallbacks.CBCecCommand = CecCommandCB;
 646
 647                         // create the delegate method for the configuration change callback
 648                         m_configDelegate            = gcnew CecConfigManagedDelegate(this, &CecCallbackMethods::CecConfigManaged);
 649                         m_configGCHandle            = System::Runtime::InteropServices::GCHandle::Alloc(m_configDelegate);
 650                         g_configCB                  = static_cast<CONFIGCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_configDelegate).ToPointer());
 651                         g_cecCallbacks.CBCecConfigurationChanged = CecConfigCB;
 652
 653                         delete context;
 654                 }
 655
 656         ~CecCallbackMethods(void)
 657    {
 658      DestroyDelegates();
 659    }
 660
 661         protected:
 662    !CecCallbackMethods(void)
 663    {
 664      DestroyDelegates();
 665    }
 666
 667         public:
 668                 virtual void DisableCallbacks(void)
 669                 {
 670                         if (m_bHasCallbacks)
 671                                 delete m_callbacks;
 672                         m_bHasCallbacks = false;
 673                 }
 674                 virtual bool EnableCallbacks(CecCallbackMethods ^ callbacks)
 675                 {
 676                         DisableCallbacks();
 677                         if (!m_bHasCallbacks)
 678                         {
 679                                 m_bHasCallbacks = true;
 680                                 m_callbacks = callbacks;
 681                                 return true;
 682                         }
 683
 684                         return false;
 685                 }
 686
 687                 virtual int ReceiveLogMessage(CecLogMessage ^ message)
 688                 {
 689                         return 0;
 690                 }
 691
 692                 virtual int ReceiveKeypress(CecKeypress ^ key)
 693                 {
 694                         return 0;
 695                 }
 696
 697                 virtual int ReceiveCommand(CecCommand ^ command)
 698                 {
 699                         return 0;
 700                 }
 701
 702                 virtual int ConfigurationChanged(LibCECConfiguration ^ config)
 703                 {
 704                         return 0;
 705                 }
 706         protected:
 707                 // managed callback methods
 708                 int CecLogMessageManaged(const CEC::cec_log_message &message)
 709                 {
 710                         int iReturn(0);
 711                         if (m_bHasCallbacks)
 712                                 iReturn = m_callbacks->ReceiveLogMessage(gcnew CecLogMessage(gcnew System::String(message.message), (CecLogLevel)message.level, message.time));
 713                         return iReturn;
 714                 }
 715
 716                 int CecKeyPressManaged(const CEC::cec_keypress &key)
 717                 {
 718                         int iReturn(0);
 719                         if (m_bHasCallbacks)
 720                                 iReturn = m_callbacks->ReceiveKeypress(gcnew CecKeypress(key.keycode, key.duration));
 721                         return iReturn;
 722                 }
 723
 724                 int CecCommandManaged(const CEC::cec_command &command)
 725                 {
 726                         int iReturn(0);
 727                         if (m_bHasCallbacks)
 728                         {
 729                                 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);
 730                                 for (uint8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
 731                                         newCommand->Parameters->PushBack(command.parameters[iPtr]);
 732                                 iReturn = m_callbacks->ReceiveCommand(newCommand);
 733                         }
 734                         return iReturn;
 735                 }
 736
 737                 int CecConfigManaged(const CEC::libcec_configuration &config)
 738                 {
 739                         int iReturn(0);
 740                         if (m_bHasCallbacks)
 741                         {
 742                                 LibCECConfiguration ^netConfig = gcnew LibCECConfiguration();
 743                           netConfig->DeviceName = gcnew System::String(config.strDeviceName);
 744                                 for (unsigned int iPtr = 0; iPtr < 5; iPtr++)
 745                                   netConfig->DeviceTypes->Types[iPtr] = (CecDeviceType)config.deviceTypes.types[iPtr];
 746
 747                                 netConfig->PhysicalAddress = config.iPhysicalAddress;
 748                                 netConfig->BaseDevice = (CecLogicalAddress)config.baseDevice;
 749                                 netConfig->HDMIPort = config.iHDMIPort;
 750                                 netConfig->ClientVersion = (CecClientVersion)config.clientVersion;
 751                                 netConfig->GetSettingsFromROM = config.bGetSettingsFromROM == 1;
 752                                 netConfig->ActivateSource = config.bActivateSource == 1;
 753
 754                                 netConfig->WakeDevices->Clear();
 755                                 for (uint8_t iPtr = 0; iPtr <= 16; iPtr++)
 756                                         if (config.wakeDevices[iPtr])
 757                                                 netConfig->WakeDevices->Set((CecLogicalAddress)iPtr);
 758
 759                                 netConfig->PowerOffDevices->Clear();
 760                                 for (uint8_t iPtr = 0; iPtr <= 16; iPtr++)
 761                                         if (config.powerOffDevices[iPtr])
 762                                                 netConfig->PowerOffDevices->Set((CecLogicalAddress)iPtr);
 763
 764                                 netConfig->PowerOffScreensaver = config.bPowerOffScreensaver == 1;
 765                                 netConfig->PowerOffOnStandby = config.bPowerOffOnStandby == 1;
 766
 767                                 iReturn = m_callbacks->ConfigurationChanged(netConfig);
 768                         }
 769                         return iReturn;
 770                 }
 771
 772                 void DestroyDelegates()
 773                 {
 774                         if (m_bHasCallbacks)
 775                         {
 776                                 m_bHasCallbacks = false;
 777                                 delete m_callbacks;
 778                                 m_logMessageGCHandle.Free();
 779                                 m_keypressGCHandle.Free();
 780                                 m_commandGCHandle.Free();
 781                         }
 782                 }
 783
 784                 CecLogMessageManagedDelegate ^                    m_logMessageDelegate;
 785                 static System::Runtime::InteropServices::GCHandle m_logMessageGCHandle;
 786                 LOGCB                                             m_logMessageCallback;
 787
 788                 CecKeyPressManagedDelegate ^                      m_keypressDelegate;
 789                 static System::Runtime::InteropServices::GCHandle m_keypressGCHandle;
 790                 KEYCB                                             m_keypressCallback;
 791
 792                 CecCommandManagedDelegate ^                       m_commandDelegate;
 793                 static System::Runtime::InteropServices::GCHandle m_commandGCHandle;
 794                 COMMANDCB                                         m_commandCallback;
 795
 796           CecConfigManagedDelegate ^                        m_configDelegate;
 797                 static System::Runtime::InteropServices::GCHandle m_configGCHandle;
 798                 CONFIGCB                                          m_configCallback;
 799
 800                 CecCallbackMethods ^ m_callbacks;
 801           bool                 m_bHasCallbacks;
 802         };
 803 }