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     Version1_7_0  = 0x1700
 362         };
 363
 364         public enum class CecServerVersion
 365         {
 366                 VersionPre1_5 = 0,
 367                 Version1_5_0  = 0x1500,
 368                 Version1_5_1  = 0x1501,
 369                 Version1_5_2  = 0x1502,
 370                 Version1_5_3  = 0x1503,
 371                 Version1_6_0  = 0x1600,
 372                 Version1_6_1  = 0x1601,
 373     Version1_6_2  = 0x1602,
 374     Version1_6_3  = 0x1603,
 375     Version1_7_0  = 0x1700
 376         };
 377
 378         public ref class CecAdapter
 379         {
 380         public:
 381                 CecAdapter(System::String ^ strPath, System::String ^ strComPort)
 382                 {
 383                         Path = strPath;
 384                         ComPort = strComPort;
 385                 }
 386
 387                 property System::String ^ Path;
 388                 property System::String ^ ComPort;
 389         };
 390
 391         public ref class CecDeviceTypeList
 392         {
 393         public:
 394                 CecDeviceTypeList(void)
 395                 {
 396                         Types = gcnew array<CecDeviceType>(5);
 397                         for (unsigned int iPtr = 0; iPtr < 5; iPtr++)
 398                                 Types[iPtr] = CecDeviceType::Reserved;
 399                 }
 400
 401                 property array<CecDeviceType> ^ Types;
 402         };
 403
 404         public ref class CecLogicalAddresses
 405         {
 406         public:
 407                 CecLogicalAddresses(void)
 408                 {
 409                         Addresses = gcnew array<CecLogicalAddress>(16);
 410                         Clear();
 411                 }
 412
 413                 void Clear(void)
 414                 {
 415                         for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
 416                                 Addresses[iPtr] = CecLogicalAddress::Unknown;
 417                 }
 418
 419                 bool IsSet(CecLogicalAddress iAddress)
 420                 {
 421                         return Addresses[(unsigned int)iAddress] != CecLogicalAddress::Unknown;
 422                 }
 423
 424           void Set(CecLogicalAddress iAddress)
 425                 {
 426                         Addresses[(unsigned int)iAddress] = iAddress;
 427                 }
 428
 429                 property CecLogicalAddress          Primary;
 430                 property array<CecLogicalAddress> ^ Addresses;
 431         };
 432
 433         public ref class CecDatapacket
 434         {
 435         public:
 436                 CecDatapacket(void)
 437                 {
 438                         Data = gcnew array<uint8_t>(100);
 439                         Size = 0;
 440                 }
 441
 442                 void PushBack(uint8_t data)
 443                 {
 444                         if (Size < 100)
 445                         {
 446                                 Data[Size] = data;
 447                                 Size++;
 448                         }
 449                 }
 450
 451                 property array<uint8_t> ^ Data;
 452                 property uint8_t          Size;
 453         };
 454
 455         public ref class CecCommand
 456         {
 457         public:
 458                 CecCommand(CecLogicalAddress iInitiator, CecLogicalAddress iDestination, bool bAck, bool bEom, CecOpcode iOpcode, int32_t iTransmitTimeout)
 459                 {
 460                         Initiator       = iInitiator;
 461                         Destination     = iDestination;
 462                         Ack             = bAck;
 463                         Eom             = bEom;
 464                         Opcode          = iOpcode;
 465                         OpcodeSet       = true;
 466                         TransmitTimeout = iTransmitTimeout;
 467                         Parameters      = gcnew CecDatapacket;
 468                         Empty           = false;
 469                 }
 470
 471                 CecCommand(void)
 472                 {
 473                         Initiator       = CecLogicalAddress::Unknown;
 474                         Destination     = CecLogicalAddress::Unknown;
 475                         Ack             = false;
 476                         Eom             = false;
 477                         Opcode          = CecOpcode::None;
 478                         OpcodeSet       = false;
 479                         TransmitTimeout = 0;
 480                         Parameters      = gcnew CecDatapacket;
 481                         Empty           = true;
 482                 }
 483
 484                 void PushBack(uint8_t data)
 485                 {
 486                         if (Initiator == CecLogicalAddress::Unknown && Destination == CecLogicalAddress::Unknown)
 487                         {
 488                                 Initiator   = (CecLogicalAddress) (data >> 4);
 489                                 Destination = (CecLogicalAddress) (data & 0xF);
 490                         }
 491                         else if (!OpcodeSet)
 492                         {
 493                                 OpcodeSet = true;
 494                                 Opcode    = (CecOpcode)data;
 495                         }
 496                         else
 497                         {
 498                                 Parameters->PushBack(data);
 499                         }
 500                 }
 501
 502                 property bool               Empty;
 503                 property CecLogicalAddress  Initiator;
 504                 property CecLogicalAddress  Destination;
 505                 property bool               Ack;
 506                 property bool               Eom;
 507                 property CecOpcode          Opcode;
 508                 property CecDatapacket ^    Parameters;
 509                 property bool               OpcodeSet;
 510                 property int32_t            TransmitTimeout;
 511         };
 512
 513         public ref class CecKeypress
 514         {
 515         public:
 516                 CecKeypress(CecUserControlCode iKeycode, unsigned int iDuration)
 517                 {
 518                         Keycode  = iKeycode;
 519                         Duration = iDuration;
 520                         Empty    = false;
 521                 }
 522
 523                 CecKeypress(void)
 524                 {
 525                         Keycode  = CecUserControlCode::Unknown;
 526                         Duration = 0;
 527                         Empty    = true;
 528                 }
 529
 530                 property bool               Empty;
 531                 property CecUserControlCode Keycode;
 532                 property unsigned int       Duration;
 533         };
 534
 535         public ref class CecLogMessage
 536         {
 537         public:
 538                 CecLogMessage(System::String ^ strMessage, CecLogLevel iLevel, int64_t iTime)
 539                 {
 540                         Message = strMessage;
 541                         Level   = iLevel;
 542                         Time    = iTime;
 543                         Empty   = false;
 544                 }
 545
 546                 CecLogMessage(void)
 547                 {
 548                         Message = "";
 549                         Level   = CecLogLevel::None;
 550                         Time    = 0;
 551                         Empty   = true;
 552                 }
 553
 554                 property bool            Empty;
 555                 property System::String ^Message;
 556                 property CecLogLevel     Level;
 557                 property int64_t         Time;
 558         };
 559
 560         ref class CecCallbackMethods; //forward
 561         public ref class LibCECConfiguration
 562         {
 563         public:
 564                 LibCECConfiguration(void)
 565                 {
 566                         DeviceName          = "";
 567                         DeviceTypes         = gcnew CecDeviceTypeList();
 568                         AutodetectAddress  = true;
 569                         PhysicalAddress     = CEC_DEFAULT_PHYSICAL_ADDRESS;
 570                         BaseDevice          = (CecLogicalAddress)CEC_DEFAULT_BASE_DEVICE;
 571                         HDMIPort            = CEC_DEFAULT_HDMI_PORT;
 572                         ClientVersion       = CecClientVersion::VersionPre1_5;
 573                         ServerVersion       = CecServerVersion::VersionPre1_5;
 574                         TvVendor            = CecVendorId::Unknown;
 575
 576                         GetSettingsFromROM  = false;
 577                         UseTVMenuLanguage   = CEC_DEFAULT_SETTING_USE_TV_MENU_LANGUAGE == 1;
 578                         ActivateSource      = CEC_DEFAULT_SETTING_ACTIVATE_SOURCE == 1;
 579
 580                         WakeDevices         = gcnew CecLogicalAddresses();
 581                         if (CEC_DEFAULT_SETTING_ACTIVATE_SOURCE == 1)
 582                                 WakeDevices->Set(CecLogicalAddress::Tv);
 583
 584                         PowerOffDevices     = gcnew CecLogicalAddresses();
 585                         if (CEC_DEFAULT_SETTING_POWER_OFF_SHUTDOWN == 1)
 586                                 PowerOffDevices->Set(CecLogicalAddress::Broadcast);
 587
 588                         PowerOffScreensaver = CEC_DEFAULT_SETTING_POWER_OFF_SCREENSAVER == 1;
 589                         PowerOffOnStandby   = CEC_DEFAULT_SETTING_POWER_OFF_ON_STANDBY == 1;
 590
 591                         SendInactiveSource  = CEC_DEFAULT_SETTING_SEND_INACTIVE_SOURCE == 1;
 592                         LogicalAddresses    = gcnew CecLogicalAddresses();
 593                         FirmwareVersion     = 1;
 594                         PowerOffDevicesOnStandby = CEC_DEFAULT_SETTING_POWER_OFF_DEVICES_STANDBY == 1;
 595                         ShutdownOnStandby   = CEC_DEFAULT_SETTING_SHUTDOWN_ON_STANDBY == 1;
 596                         DeviceLanguage      = "";
 597                 }
 598
 599                 void SetCallbacks(CecCallbackMethods ^callbacks)
 600                 {
 601                         Callbacks = callbacks;
 602                 }
 603
 604                 void Update(const CEC::libcec_configuration &config)
 605                 {
 606                         DeviceName = gcnew System::String(config.strDeviceName);
 607
 608                         for (unsigned int iPtr = 0; iPtr < 5; iPtr++)
 609                                 DeviceTypes->Types[iPtr] = (CecDeviceType)config.deviceTypes.types[iPtr];
 610
 611                         AutodetectAddress  = config.bAutodetectAddress == 1;
 612                         PhysicalAddress    = config.iPhysicalAddress;
 613                         BaseDevice         = (CecLogicalAddress)config.baseDevice;
 614                         HDMIPort           = config.iHDMIPort;
 615                         ClientVersion      = (CecClientVersion)config.clientVersion;
 616                         ServerVersion      = (CecServerVersion)config.serverVersion;
 617                         TvVendor           = (CecVendorId)config.tvVendor;
 618
 619                         // player specific settings
 620                         GetSettingsFromROM = config.bGetSettingsFromROM == 1;
 621                         UseTVMenuLanguage = config.bUseTVMenuLanguage == 1;
 622                         ActivateSource = config.bActivateSource == 1;
 623
 624                         WakeDevices->Clear();
 625                         for (uint8_t iPtr = 0; iPtr <= 16; iPtr++)
 626                                 if (config.wakeDevices[iPtr])
 627                                         WakeDevices->Set((CecLogicalAddress)iPtr);
 628
 629                         PowerOffDevices->Clear();
 630                         for (uint8_t iPtr = 0; iPtr <= 16; iPtr++)
 631                                 if (config.powerOffDevices[iPtr])
 632                                         PowerOffDevices->Set((CecLogicalAddress)iPtr);
 633
 634                         PowerOffScreensaver = config.bPowerOffScreensaver == 1;
 635                         PowerOffOnStandby = config.bPowerOffOnStandby == 1;
 636
 637                         if (ServerVersion >= CecServerVersion::Version1_5_1)
 638                                 SendInactiveSource = config.bSendInactiveSource == 1;
 639
 640                         if (ServerVersion >= CecServerVersion::Version1_5_3)
 641                         {
 642                                 LogicalAddresses->Clear();
 643                                 for (uint8_t iPtr = 0; iPtr <= 16; iPtr++)
 644                                         if (config.logicalAddresses[iPtr])
 645                                                 LogicalAddresses->Set((CecLogicalAddress)iPtr);
 646                         }
 647
 648                         if (ServerVersion >= CecServerVersion::Version1_6_0)
 649                         {
 650                                 FirmwareVersion          = config.iFirmwareVersion;
 651                                 PowerOffDevicesOnStandby = config.bPowerOffDevicesOnStandby == 1;
 652                                 ShutdownOnStandby        = config.bShutdownOnStandby == 1;
 653                         }
 654
 655                         if (ServerVersion >= CecServerVersion::Version1_6_2)
 656                                 DeviceLanguage = gcnew System::String(config.strDeviceLanguage);
 657
 658                         if (ServerVersion >= CecServerVersion::Version1_6_3)
 659                           MonitorOnlyClient = config.bMonitorOnly == 1;
 660                 }
 661
 662                 property System::String ^     DeviceName;
 663                 property CecDeviceTypeList ^  DeviceTypes;
 664                 property bool                 AutodetectAddress;
 665                 property uint16_t             PhysicalAddress;
 666                 property CecLogicalAddress    BaseDevice;
 667                 property uint8_t              HDMIPort;
 668                 property CecClientVersion     ClientVersion;
 669                 property CecServerVersion     ServerVersion;
 670                 property CecVendorId          TvVendor;
 671
 672                 // player specific settings
 673                 property bool                 GetSettingsFromROM;
 674                 property bool                 UseTVMenuLanguage;
 675                 property bool                 ActivateSource;
 676                 property CecLogicalAddresses ^WakeDevices;
 677                 property CecLogicalAddresses ^PowerOffDevices;
 678                 property bool                 PowerOffScreensaver;
 679                 property bool                 PowerOffOnStandby;
 680                 property bool                 SendInactiveSource;
 681                 property CecLogicalAddresses ^LogicalAddresses;
 682                 property uint16_t             FirmwareVersion;
 683                 property bool                 PowerOffDevicesOnStandby;
 684                 property bool                 ShutdownOnStandby;
 685                 property bool                 MonitorOnlyClient;
 686                 property System::String ^     DeviceLanguage;
 687                 property CecCallbackMethods ^ Callbacks;
 688         };
 689
 690         // the callback methods are called by unmanaged code, so we need some delegates for this
 691         #pragma unmanaged
 692         // unmanaged callback methods
 693         typedef int (__stdcall *LOGCB)    (const CEC::cec_log_message &message);
 694         typedef int (__stdcall *KEYCB)    (const CEC::cec_keypress &key);
 695         typedef int (__stdcall *COMMANDCB)(const CEC::cec_command &command);
 696         typedef int (__stdcall *CONFIGCB) (const CEC::libcec_configuration &config);
 697         typedef int (__stdcall *ALERTCB)  (const CEC::libcec_alert, const CEC::libcec_parameter &data);
 698         typedef int (__stdcall *MENUCB)   (const CEC::cec_menu_state newVal);
 699
 700         static LOGCB              g_logCB;
 701         static KEYCB              g_keyCB;
 702         static COMMANDCB          g_commandCB;
 703         static CONFIGCB           g_configCB;
 704         static ALERTCB            g_alertCB;
 705         static MENUCB             g_menuCB;
 706         static CEC::ICECCallbacks g_cecCallbacks;
 707
 708         int CecLogMessageCB(void *cbParam, const CEC::cec_log_message &message)
 709         {
 710                 if (g_logCB)
 711                         return g_logCB(message);
 712                 return 0;
 713         }
 714
 715         int CecKeyPressCB(void *cbParam, const CEC::cec_keypress &key)
 716         {
 717                 if (g_keyCB)
 718                         return g_keyCB(key);
 719                 return 0;
 720         }
 721
 722         int CecCommandCB(void *cbParam, const CEC::cec_command &command)
 723         {
 724                 if (g_commandCB)
 725                         return g_commandCB(command);
 726                 return 0;
 727         }
 728
 729   int CecConfigCB(void *cbParam, const CEC::libcec_configuration &config)
 730         {
 731                 if (g_configCB)
 732                         return g_configCB(config);
 733                 return 0;
 734         }
 735
 736         int CecAlertCB(void *cbParam, const CEC::libcec_alert alert, const CEC::libcec_parameter &data)
 737         {
 738                 if (g_alertCB)
 739                         return g_alertCB(alert, data);
 740                 return 0;
 741         }
 742
 743         int CecMenuCB(void *cbParam, const CEC::cec_menu_state newVal)
 744         {
 745                 if (g_menuCB)
 746                         return g_menuCB(newVal);
 747                 return 0;
 748         }
 749
 750         #pragma managed
 751         // delegates for the unmanaged callback methods
 752         public delegate int CecLogMessageManagedDelegate(const CEC::cec_log_message &);
 753         public delegate int CecKeyPressManagedDelegate(const CEC::cec_keypress &);
 754         public delegate int CecCommandManagedDelegate(const CEC::cec_command &);
 755         public delegate int CecConfigManagedDelegate(const CEC::libcec_configuration &);
 756         public delegate int CecAlertManagedDelegate(const CEC::libcec_alert, const CEC::libcec_parameter &);
 757         public delegate int CecMenuManagedDelegate(const CEC::cec_menu_state newVal);
 758
 759         // callback method interface
 760         public ref class CecCallbackMethods
 761         {
 762         public:
 763     CecCallbackMethods(void)
 764     {
 765       m_bHasCallbacks = false;
 766       m_bDelegatesCreated = false;
 767     }
 768
 769         ~CecCallbackMethods(void)
 770    {
 771      DestroyDelegates();
 772    }
 773
 774         protected:
 775    !CecCallbackMethods(void)
 776    {
 777      DestroyDelegates();
 778    }
 779
 780         public:
 781                 virtual void DisableCallbacks(void)
 782                 {
 783                         DestroyDelegates();
 784                 }
 785
 786                 virtual bool EnableCallbacks(CecCallbackMethods ^ callbacks)
 787                 {
 788       CreateDelegates();
 789                         if (!m_bHasCallbacks)
 790                         {
 791                                 m_bHasCallbacks = true;
 792                                 m_callbacks = callbacks;
 793                                 return true;
 794                         }
 795
 796                         return false;
 797                 }
 798
 799                 virtual int ReceiveLogMessage(CecLogMessage ^ message)
 800                 {
 801                         return 0;
 802                 }
 803
 804                 virtual int ReceiveKeypress(CecKeypress ^ key)
 805                 {
 806                         return 0;
 807                 }
 808
 809                 virtual int ReceiveCommand(CecCommand ^ command)
 810                 {
 811                         return 0;
 812                 }
 813
 814                 virtual int ConfigurationChanged(LibCECConfiguration ^ config)
 815                 {
 816                         return 0;
 817                 }
 818
 819                 virtual int ReceiveAlert(CecAlert alert, CecParameter ^ data)
 820                 {
 821                         return 0;
 822                 }
 823
 824                 virtual int ReceiveMenuStateChange(CecMenuState newVal)
 825                 {
 826                         return 0;
 827                 }
 828
 829         protected:
 830                 // managed callback methods
 831                 int CecLogMessageManaged(const CEC::cec_log_message &message)
 832                 {
 833                         int iReturn(0);
 834                         if (m_bHasCallbacks)
 835                                 iReturn = m_callbacks->ReceiveLogMessage(gcnew CecLogMessage(gcnew System::String(message.message), (CecLogLevel)message.level, message.time));
 836                         return iReturn;
 837                 }
 838
 839                 int CecKeyPressManaged(const CEC::cec_keypress &key)
 840                 {
 841                         int iReturn(0);
 842                         if (m_bHasCallbacks)
 843                                 iReturn = m_callbacks->ReceiveKeypress(gcnew CecKeypress((CecUserControlCode)key.keycode, key.duration));
 844                         return iReturn;
 845                 }
 846
 847                 int CecCommandManaged(const CEC::cec_command &command)
 848                 {
 849                         int iReturn(0);
 850                         if (m_bHasCallbacks)
 851                         {
 852                                 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);
 853                                 for (uint8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
 854                                         newCommand->Parameters->PushBack(command.parameters[iPtr]);
 855                                 iReturn = m_callbacks->ReceiveCommand(newCommand);
 856                         }
 857                         return iReturn;
 858                 }
 859
 860                 int CecConfigManaged(const CEC::libcec_configuration &config)
 861                 {
 862                         int iReturn(0);
 863                         if (m_bHasCallbacks)
 864                         {
 865                                 LibCECConfiguration ^netConfig = gcnew LibCECConfiguration();
 866                                 netConfig->Update(config);
 867                                 iReturn = m_callbacks->ConfigurationChanged(netConfig);
 868                         }
 869                         return iReturn;
 870                 }
 871
 872                 int CecAlertManaged(const CEC::libcec_alert alert, const CEC::libcec_parameter &data)
 873                 {
 874                         int iReturn(0);
 875                         if (m_bHasCallbacks)
 876                         {
 877                                 CecParameterType newType = (CecParameterType)data.paramType;
 878                                 if (newType == CecParameterType::ParameterTypeString)
 879                                 {
 880                                         System::String ^ newData = gcnew System::String((const char *)data.paramData, 0, 128);
 881                                         CecParameter ^ newParam = gcnew CecParameter(newType, newData);
 882                                     iReturn = m_callbacks->ReceiveAlert((CecAlert)alert, newParam);
 883                                 }
 884                         }
 885                         return iReturn;
 886                 }
 887
 888                 int CecMenuManaged(const CEC::cec_menu_state newVal)
 889                 {
 890                         int iReturn(0);
 891                         if (m_bHasCallbacks)
 892                         {
 893                                 iReturn = m_callbacks->ReceiveMenuStateChange((CecMenuState)newVal);
 894                         }
 895                         return iReturn;
 896                 }
 897
 898                 void DestroyDelegates()
 899                 {
 900       m_bHasCallbacks = false;
 901                         if (m_bDelegatesCreated)
 902                         {
 903         m_bDelegatesCreated = false;
 904                                 m_logMessageGCHandle.Free();
 905                                 m_keypressGCHandle.Free();
 906                                 m_commandGCHandle.Free();
 907                                 m_alertGCHandle.Free();
 908                                 m_menuGCHandle.Free();
 909                         }
 910                 }
 911
 912     void CreateDelegates()
 913     {
 914       DestroyDelegates();
 915
 916       if (!m_bDelegatesCreated)
 917       {
 918         msclr::interop::marshal_context ^ context = gcnew msclr::interop::marshal_context();
 919
 920         // create the delegate method for the log message callback
 921         m_logMessageDelegate           = gcnew CecLogMessageManagedDelegate(this, &CecCallbackMethods::CecLogMessageManaged);
 922         m_logMessageGCHandle           = System::Runtime::InteropServices::GCHandle::Alloc(m_logMessageDelegate);
 923         g_logCB                        = static_cast<LOGCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_logMessageDelegate).ToPointer());
 924         g_cecCallbacks.CBCecLogMessage = CecLogMessageCB;
 925
 926         // create the delegate method for the keypress callback
 927         m_keypressDelegate           = gcnew CecKeyPressManagedDelegate(this, &CecCallbackMethods::CecKeyPressManaged);
 928         m_keypressGCHandle           = System::Runtime::InteropServices::GCHandle::Alloc(m_keypressDelegate);
 929         g_keyCB                      = static_cast<KEYCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_keypressDelegate).ToPointer());
 930         g_cecCallbacks.CBCecKeyPress = CecKeyPressCB;
 931
 932         // create the delegate method for the command callback
 933         m_commandDelegate           = gcnew CecCommandManagedDelegate(this, &CecCallbackMethods::CecCommandManaged);
 934         m_commandGCHandle           = System::Runtime::InteropServices::GCHandle::Alloc(m_commandDelegate);
 935         g_commandCB                 = static_cast<COMMANDCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_commandDelegate).ToPointer());
 936         g_cecCallbacks.CBCecCommand = CecCommandCB;
 937
 938         // create the delegate method for the configuration change callback
 939         m_configDelegate            = gcnew CecConfigManagedDelegate(this, &CecCallbackMethods::CecConfigManaged);
 940         m_configGCHandle            = System::Runtime::InteropServices::GCHandle::Alloc(m_configDelegate);
 941         g_configCB                  = static_cast<CONFIGCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_configDelegate).ToPointer());
 942         g_cecCallbacks.CBCecConfigurationChanged = CecConfigCB;
 943
 944         // create the delegate method for the alert callback
 945         m_alertDelegate            = gcnew CecAlertManagedDelegate(this, &CecCallbackMethods::CecAlertManaged);
 946         m_alertGCHandle            = System::Runtime::InteropServices::GCHandle::Alloc(m_alertDelegate);
 947         g_alertCB                  = static_cast<ALERTCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_alertDelegate).ToPointer());
 948         g_cecCallbacks.CBCecAlert  = CecAlertCB;
 949
 950         // create the delegate method for the menu callback
 951         m_menuDelegate             = gcnew CecMenuManagedDelegate(this, &CecCallbackMethods::CecMenuManaged);
 952         m_menuGCHandle             = System::Runtime::InteropServices::GCHandle::Alloc(m_menuDelegate);
 953         g_menuCB                   = static_cast<MENUCB>(System::Runtime::InteropServices::Marshal::GetFunctionPointerForDelegate(m_menuDelegate).ToPointer());
 954         g_cecCallbacks.CBCecMenuStateChanged = CecMenuCB;
 955
 956         delete context;
 957         m_bDelegatesCreated = true;
 958       }
 959     }
 960
 961                 CecLogMessageManagedDelegate ^                    m_logMessageDelegate;
 962                 static System::Runtime::InteropServices::GCHandle m_logMessageGCHandle;
 963                 LOGCB                                             m_logMessageCallback;
 964
 965                 CecKeyPressManagedDelegate ^                      m_keypressDelegate;
 966                 static System::Runtime::InteropServices::GCHandle m_keypressGCHandle;
 967                 KEYCB                                             m_keypressCallback;
 968
 969                 CecCommandManagedDelegate ^                       m_commandDelegate;
 970                 static System::Runtime::InteropServices::GCHandle m_commandGCHandle;
 971                 COMMANDCB                                         m_commandCallback;
 972
 973           CecConfigManagedDelegate ^                        m_configDelegate;
 974                 static System::Runtime::InteropServices::GCHandle m_configGCHandle;
 975                 CONFIGCB                                          m_configCallback;
 976
 977                 CecAlertManagedDelegate ^                         m_alertDelegate;
 978                 static System::Runtime::InteropServices::GCHandle m_alertGCHandle;
 979                 CONFIGCB                                          m_alertCallback;
 980
 981                 CecMenuManagedDelegate ^                          m_menuDelegate;
 982                 static System::Runtime::InteropServices::GCHandle m_menuGCHandle;
 983                 MENUCB                                            m_menuCallback;
 984
 985                 CecCallbackMethods ^ m_callbacks;
 986           bool                 m_bHasCallbacks;
 987     bool                 m_bDelegatesCreated;
 988         };
 989 }