src/cec-config-gui/CecConfigGUI.cs

   1 using System;
   2 using System.Collections.Generic;
   3 using System.Drawing;
   4 using System.Text;
   5 using System.Windows.Forms;
   6 using System.Threading;
   7 using CecSharp;
   8 using CecConfigGui.actions;
   9 using System.Globalization;
  10 using System.IO;
  11 using System.Xml;
  12
  13 namespace CecConfigGui
  14 {
  15   internal enum ConfigTab
  16   {
  17     Configuration,
  18     KeyConfiguration,
  19     Tester,
  20     Log
  21   }
  22
  23   public partial class CecConfigGUI : AsyncForm
  24   {
  25     public CecConfigGUI()
  26     {
  27       Config = new LibCECConfiguration();
  28       Config.DeviceTypes.Types[0] = CecDeviceType.RecordingDevice;
  29       Config.DeviceName = "CEC Config";
  30       Config.GetSettingsFromROM = true;
  31       Config.ClientVersion = CecClientVersion.Version1_5_1;
  32       Callbacks = new CecCallbackWrapper(this);
  33       Config.SetCallbacks(Callbacks);
  34       LoadXMLConfiguration(ref Config);
  35       Lib = new LibCecSharp(Config);
  36
  37       InitializeComponent();
  38       LoadButtonConfiguration();
  39
  40       ActiveProcess = new ConnectToDevice(ref Lib, Config);
  41       ActiveProcess.EventHandler += ProcessEventHandler;
  42       (new Thread(ActiveProcess.Run)).Start();
  43     }
  44
  45     private bool LoadXMLConfiguration(ref LibCECConfiguration config)
  46     {
  47       bool gotConfig = false;
  48       string xbmcDir = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + @"\XBMC\userdata\peripheral_data";
  49       string defaultDir = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
  50       string file = defaultDir + @"\usb_2548_1001.xml";
  51       if (File.Exists(xbmcDir + @"\usb_2548_1001.xml"))
  52         file = xbmcDir + @"\usb_2548_1001.xml";
  53
  54       if (File.Exists(file))
  55       {
  56         XmlTextReader reader = new XmlTextReader(file);
  57         while (reader.Read())
  58         {
  59           gotConfig = true;
  60           switch (reader.NodeType)
  61           {
  62             case XmlNodeType.Element:
  63               if (reader.Name.ToLower() == "setting")
  64               {
  65                 string name = string.Empty;
  66                 string value = string.Empty;
  67
  68                 while (reader.MoveToNextAttribute())
  69                 {
  70                   if (reader.Name.ToLower().Equals("id"))
  71                     name = reader.Value.ToLower();
  72                   if (reader.Name.ToLower().Equals("value"))
  73                     value = reader.Value;
  74                 }
  75
  76                 switch (name)
  77                 {
  78                   case "cec_hdmi_port":
  79                     {
  80                       byte iPort;
  81                       if (byte.TryParse(value, out iPort))
  82                         config.HDMIPort = iPort;
  83                     }
  84                     break;
  85                   case "connected_device":
  86                     {
  87                       ushort iDevice;
  88                       if (ushort.TryParse(value, out iDevice))
  89                         config.BaseDevice = (CecLogicalAddress)iDevice;
  90                     }
  91                     break;
  92                   case "cec_power_on_startup":
  93                     if (value.Equals("1") || value.ToLower().Equals("true") || value.ToLower().Equals("yes"))
  94                     {
  95                       config.ActivateSource = true;
  96                       config.WakeDevices.Set(CecLogicalAddress.Tv);
  97                     }
  98                     break;
  99                   case "cec_power_off_shutdown":
 100                     if (value.Equals("1") || value.ToLower().Equals("true") || value.ToLower().Equals("yes"))
 101                       config.PowerOffDevices.Set(CecLogicalAddress.Broadcast);
 102                     break;
 103                   case "cec_standby_screensaver":
 104                     config.PowerOffScreensaver = value.Equals("1") || value.ToLower().Equals("true") || value.ToLower().Equals("yes");
 105                     break;
 106                   case "standby_pc_on_tv_standby":
 107                     config.PowerOffOnStandby = value.Equals("1") || value.ToLower().Equals("true") || value.ToLower().Equals("yes");
 108                     break;
 109                   case "use_tv_menu_language":
 110                     config.UseTVMenuLanguage = value.Equals("1") || value.ToLower().Equals("true") || value.ToLower().Equals("yes");
 111                     break;
 112                   // 1.5.0+ settings
 113                   case "physical_address":
 114                     {
 115                       ushort physicalAddress = 0;
 116                       if (ushort.TryParse(value, NumberStyles.AllowHexSpecifier, null, out physicalAddress))
 117                         config.PhysicalAddress = physicalAddress;
 118                     }
 119                     break;
 120                   case "device_type":
 121                     {
 122                       ushort iType;
 123                       if (ushort.TryParse(value, out iType))
 124                         config.DeviceTypes.Types[0] = (CecDeviceType)iType;
 125                     }
 126                     break;
 127                   case "tv_vendor":
 128                     {
 129                       UInt64 iVendor;
 130                       if (UInt64.TryParse(value, out iVendor))
 131                         config.TvVendor = (CecVendorId)iVendor;
 132                     }
 133                     break;
 134                   case "wake_devices":
 135                     {
 136                       config.WakeDevices.Clear();
 137                       string[] split = value.Split(new[] { ' ' });
 138                       foreach (string dev in split)
 139                       {
 140                         byte iLogicalAddress;
 141                         if (byte.TryParse(dev, out iLogicalAddress))
 142                           config.WakeDevices.Set((CecLogicalAddress)iLogicalAddress);
 143                       }
 144                     }
 145                     break;
 146                   case "standby_devices":
 147                     {
 148                       config.PowerOffDevices.Clear();
 149                       string[] split = value.Split(new char[] { ' ' });
 150                       foreach (string dev in split)
 151                       {
 152                         byte iLogicalAddress;
 153                         if (byte.TryParse(dev, out iLogicalAddress))
 154                           config.PowerOffDevices.Set((CecLogicalAddress)iLogicalAddress);
 155                       }
 156                     }
 157                     break;
 158                   case "enabled":
 159                     break;
 160                   case "port":
 161                     //TODO
 162                     break;
 163                   // 1.5.1 settings
 164                   case "send_inactive_source":
 165                     config.SendInactiveSource = value.Equals("1") || value.ToLower().Equals("true") || value.ToLower().Equals("yes");
 166                     break;
 167                   default:
 168                     break;
 169                 }
 170               }
 171               break;
 172             default:
 173               break;
 174           }
 175         }
 176       }
 177       return gotConfig;
 178     }
 179
 180     private void LoadButtonConfiguration()
 181     {
 182       //TODO load the real configuration
 183       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Select", (new CecKeypress { Keycode = 0x00 }), string.Empty));
 184       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Up", (new CecKeypress { Keycode = 0x01 }), string.Empty));
 185       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Down", (new CecKeypress { Keycode = 0x02 }), string.Empty));
 186       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Left", (new CecKeypress { Keycode = 0x03 }), string.Empty));
 187       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Right", (new CecKeypress { Keycode = 0x04 }), string.Empty));
 188       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Right+Up", (new CecKeypress { Keycode = 0x05 }), string.Empty));
 189       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Right+Down", (new CecKeypress { Keycode = 0x06 }), string.Empty));
 190       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Left+Up", (new CecKeypress { Keycode = 0x07 }), string.Empty));
 191       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Left+Down", (new CecKeypress { Keycode = 0x08 }), string.Empty));
 192       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Root menu", (new CecKeypress { Keycode = 0x09 }), string.Empty));
 193       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Setup menu", (new CecKeypress { Keycode = 0x0A }), string.Empty));
 194       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Contents menu", (new CecKeypress { Keycode = 0x0B }), string.Empty));
 195       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Favourite menu", (new CecKeypress { Keycode = 0x0C }), string.Empty));
 196       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Exit", (new CecKeypress { Keycode = 0x0D }), string.Empty));
 197       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("0", (new CecKeypress { Keycode = 0x20 }), string.Empty));
 198       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("1", (new CecKeypress { Keycode = 0x21 }), string.Empty));
 199       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("2", (new CecKeypress { Keycode = 0x22 }), string.Empty));
 200       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("3", (new CecKeypress { Keycode = 0x23 }), string.Empty));
 201       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("4", (new CecKeypress { Keycode = 0x24 }), string.Empty));
 202       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("5", (new CecKeypress { Keycode = 0x25 }), string.Empty));
 203       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("6", (new CecKeypress { Keycode = 0x26 }), string.Empty));
 204       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("7", (new CecKeypress { Keycode = 0x27 }), string.Empty));
 205       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("8", (new CecKeypress { Keycode = 0x28 }), string.Empty));
 206       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("9", (new CecKeypress { Keycode = 0x29 }), string.Empty));
 207       cecButtonConfigBindingSource.Add(new CecButtonConfigItem(".", (new CecKeypress { Keycode = 0x2A }), string.Empty));
 208       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Enter", (new CecKeypress { Keycode = 0x2B }), string.Empty));
 209       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Clear", (new CecKeypress { Keycode = 0x2C }), string.Empty));
 210       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Next favourite", (new CecKeypress { Keycode = 0x2F }), string.Empty));
 211       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Channel up", (new CecKeypress { Keycode = 0x30 }), string.Empty));
 212       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Channel down", (new CecKeypress { Keycode = 0x31 }), string.Empty));
 213       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Previous channel", (new CecKeypress { Keycode = 0x32 }), string.Empty));
 214       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Sound select", (new CecKeypress { Keycode = 0x33 }), string.Empty));
 215       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Input select", (new CecKeypress { Keycode = 0x34 }), string.Empty));
 216       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Display information", (new CecKeypress { Keycode = 0x35 }), string.Empty));
 217       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Help", (new CecKeypress { Keycode = 0x36 }), string.Empty));
 218       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Page up", (new CecKeypress { Keycode = 0x37 }), string.Empty));
 219       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Page down", (new CecKeypress { Keycode = 0x38 }), string.Empty));
 220       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Power", (new CecKeypress { Keycode = 0x40 }), string.Empty));
 221       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Volume up", (new CecKeypress { Keycode = 0x41 }), string.Empty));
 222       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Volume down", (new CecKeypress { Keycode = 0x42 }), string.Empty));
 223       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Mute", (new CecKeypress { Keycode = 0x43 }), string.Empty));
 224       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Play", (new CecKeypress { Keycode = 0x44 }), string.Empty));
 225       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Stop", (new CecKeypress { Keycode = 0x45 }), string.Empty));
 226       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Pause", (new CecKeypress { Keycode = 0x46 }), string.Empty));
 227       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Record", (new CecKeypress { Keycode = 0x47 }), string.Empty));
 228       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Rewind", (new CecKeypress { Keycode = 0x48 }), string.Empty));
 229       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Fast forward", (new CecKeypress { Keycode = 0x49 }), string.Empty));
 230       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Eject", (new CecKeypress { Keycode = 0x4A }), string.Empty));
 231       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Forward", (new CecKeypress { Keycode = 0x4B }), string.Empty));
 232       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Backward", (new CecKeypress { Keycode = 0x4C }), string.Empty));
 233       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Stop record", (new CecKeypress { Keycode = 0x4D }), string.Empty));
 234       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Pause record", (new CecKeypress { Keycode = 0x4E }), string.Empty));
 235       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Angle", (new CecKeypress { Keycode = 0x50 }), string.Empty));
 236       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Sub picture", (new CecKeypress { Keycode = 0x51 }), string.Empty));
 237       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Video on demand", (new CecKeypress { Keycode = 0x52 }), string.Empty));
 238       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Electronic program guide", (new CecKeypress { Keycode = 0x53 }), string.Empty));
 239       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Timer programming", (new CecKeypress { Keycode = 0x54 }), string.Empty));
 240       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Initial configuration", (new CecKeypress { Keycode = 0x55 }), string.Empty));
 241       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Play (function)", (new CecKeypress { Keycode = 0x60 }), string.Empty));
 242       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Pause play (function)", (new CecKeypress { Keycode = 0x61 }), string.Empty));
 243       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Record (function)", (new CecKeypress { Keycode = 0x62 }), string.Empty));
 244       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Pause record (function)", (new CecKeypress { Keycode = 0x63 }), string.Empty));
 245       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Stop (function)", (new CecKeypress { Keycode = 0x64 }), string.Empty));
 246       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Mute (function)", (new CecKeypress { Keycode = 0x65 }), string.Empty));
 247       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Restore volume", (new CecKeypress { Keycode = 0x66 }), string.Empty));
 248       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Tune", (new CecKeypress { Keycode = 0x67 }), string.Empty));
 249       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Select media", (new CecKeypress { Keycode = 0x68 }), string.Empty));
 250       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Select AV input", (new CecKeypress { Keycode = 0x69 }), string.Empty));
 251       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Select audio input", (new CecKeypress { Keycode = 0x6A }), string.Empty));
 252       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Power toggle", (new CecKeypress { Keycode = 0x6B }), string.Empty));
 253       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Power off", (new CecKeypress { Keycode = 0x6C }), string.Empty));
 254       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Power on", (new CecKeypress { Keycode = 0x6D }), string.Empty));
 255       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("F1 (blue)", (new CecKeypress { Keycode = 0x71 }), string.Empty));
 256       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("F2 (red)", (new CecKeypress { Keycode = 0x72 }), string.Empty));
 257       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("F3 (green)", (new CecKeypress { Keycode = 0x73 }), string.Empty));
 258       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("F4 (yellow)", (new CecKeypress { Keycode = 0x74 }), string.Empty));
 259       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("F5", (new CecKeypress { Keycode = 0x75 }), string.Empty));
 260       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("Data", (new CecKeypress { Keycode = 0x76 }), string.Empty));
 261       cecButtonConfigBindingSource.Add(new CecButtonConfigItem("(Samsung) Return", (new CecKeypress { Keycode = 0x91 }), string.Empty));
 262     }
 263
 264     private void ProcessEventHandler(object src, UpdateEvent updateEvent)
 265     {
 266       switch (updateEvent.Type)
 267       {
 268         case UpdateEventType.StatusText:
 269           SetControlText(lStatus, updateEvent.StringValue);
 270           break;
 271         case UpdateEventType.PhysicalAddress:
 272           Config.PhysicalAddress = (ushort)updateEvent.IntValue;
 273           SetControlText(tbPhysicalAddress, string.Format("{0,4:X}", updateEvent.IntValue));
 274           break;
 275         case UpdateEventType.ProgressBar:
 276           SetControlVisible(pProgress, true);
 277           SetProgressValue(pProgress, updateEvent.IntValue);
 278           break;
 279         case UpdateEventType.TVVendorId:
 280           TVVendor = (CecVendorId)updateEvent.IntValue;
 281           UpdateSelectedDevice();
 282           break;
 283         case UpdateEventType.BaseDevicePhysicalAddress:
 284           SetControlText(lConnectedPhysicalAddress, string.Format("Address: {0,4:X}", updateEvent.IntValue));
 285           break;
 286         case UpdateEventType.BaseDevice:
 287           Config.BaseDevice = (CecLogicalAddress)updateEvent.IntValue;
 288           break;
 289         case UpdateEventType.HDMIPort:
 290           Config.HDMIPort = (byte)updateEvent.IntValue;
 291           break;
 292         case UpdateEventType.MenuLanguage:
 293           SetControlText(cbUseTVMenuLanguage, "Use the TV's language setting" + (updateEvent.StringValue.Length > 0 ? " (" + updateEvent.StringValue + ")" : ""));
 294           break;
 295         case UpdateEventType.HasAVRDevice:
 296           if (HasAVRDevice != updateEvent.BoolValue)
 297           {
 298             HasAVRDevice = updateEvent.BoolValue;
 299             UpdateSelectedDevice();
 300           }
 301           break;
 302         case UpdateEventType.AVRVendorId:
 303           AVRVendor = (CecVendorId)updateEvent.IntValue;
 304           UpdateSelectedDevice();
 305           break;
 306         case UpdateEventType.Configuration:
 307           SuppressUpdates = true;
 308           ConfigurationChanged(updateEvent.ConfigValue);
 309           SuppressUpdates = false;
 310           break;
 311         case UpdateEventType.PollDevices:
 312           CheckActiveDevices();
 313           break;
 314         case UpdateEventType.ProcessCompleted:
 315           ActiveProcess = null;
 316           SetControlsEnabled(true);
 317           if (UpdatingInfoPanel != null)
 318           {
 319             UpdatingInfoPanel.SetControlEnabled(UpdatingInfoPanel.bUpdate, true);
 320             UpdatingInfoPanel = null;
 321           }
 322           SetControlVisible(pProgress, false);
 323           break;
 324       }
 325     }
 326
 327     private void SetControlsEnabled(bool val)
 328     {
 329       SetControlEnabled(cbPortNumber, val && !cbOverrideAddress.Checked);
 330       SetControlEnabled(cbConnectedDevice, cbConnectedDevice.Items.Count > 1 && !cbOverrideAddress.Checked && val);
 331       SetControlEnabled(cbOverrideAddress, val);
 332       SetControlEnabled(tbPhysicalAddress, val && !Config.AutodetectAddress && cbOverrideAddress.Checked);
 333       SetControlEnabled(cbDeviceType, val);
 334       SetControlEnabled(cbUseTVMenuLanguage, val);
 335       SetControlEnabled(cbActivateSource, val);
 336       SetControlEnabled(cbPowerOffScreensaver, val);
 337       SetControlEnabled(cbPowerOffOnStandby, val);
 338       SetControlEnabled(cbWakeDevices, val);
 339       SetControlEnabled(cbPowerOffDevices, val);
 340       SetControlEnabled(cbVendorOverride, val);
 341       SetControlEnabled(cbVendorId, val && cbVendorOverride.Checked);
 342       SetControlEnabled(cbSendInactiveSource, val);
 343       SetControlEnabled(bClose, val);
 344       SetControlEnabled(bSaveConfig, val);
 345       SetControlEnabled(bReloadConfig, val);
 346       SetControlEnabled(bRescanDevices, val);
 347
 348       SetControlEnabled(bSendImageViewOn, val);
 349       SetControlEnabled(bStandby, val);
 350       SetControlEnabled(bActivateSource, val);
 351       SetControlEnabled(bScan, val);
 352
 353       bool enableVolumeButtons = (GetTargetDevice() == CecLogicalAddress.AudioSystem) && val;
 354       SetControlEnabled(bVolUp, enableVolumeButtons);
 355       SetControlEnabled(bVolDown, enableVolumeButtons);
 356       SetControlEnabled(bMute, enableVolumeButtons);
 357     }
 358
 359     private void tabControl1_SelectedIndexChanged(object sender, EventArgs e)
 360     {
 361       switch (tabControl1.SelectedIndex)
 362       {
 363         case 0:
 364           SelectedTab = ConfigTab.Configuration;
 365           break;
 366         case 1:
 367           SelectedTab = ConfigTab.KeyConfiguration;
 368           break;
 369         case 2:
 370           SelectedTab = ConfigTab.Tester;
 371           break;
 372         case 3:
 373           SelectedTab = ConfigTab.Log;
 374           UpdateLog();
 375           break;
 376         default:
 377           SelectedTab = ConfigTab.Configuration;
 378           break;
 379       }
 380     }
 381
 382     protected override void Dispose(bool disposing)
 383     {
 384       if (disposing)
 385       {
 386         Lib.DisableCallbacks();
 387         Lib.StandbyDevices(CecLogicalAddress.Broadcast);
 388         Lib.Close();
 389       }
 390       if (disposing && (components != null))
 391       {
 392         components.Dispose();
 393       }
 394       base.Dispose(disposing);
 395     }
 396
 397     #region Actions
 398     public void ReloadXmlConfiguration()
 399     {
 400       LoadXMLConfiguration(ref Config);
 401       Lib.SetConfiguration(Config);
 402       ConfigurationChanged(Config);
 403     }
 404
 405     public void UpdateInfoPanel(DeviceInformation panel)
 406     {
 407       if (!SuppressUpdates && ActiveProcess == null)
 408       {
 409         SetControlsEnabled(false);
 410         UpdatingInfoPanel = panel;
 411         panel.SetControlEnabled(panel.bUpdate, false);
 412         ActiveProcess = new UpdateDeviceInfo(this, ref Lib, panel);
 413         ActiveProcess.EventHandler += ProcessEventHandler;
 414         (new Thread(ActiveProcess.Run)).Start();
 415       }
 416     }
 417
 418     public void SetPhysicalAddress(ushort physicalAddress)
 419     {
 420       if (!SuppressUpdates && ActiveProcess == null && cbOverrideAddress.Checked)
 421       {
 422         SetControlsEnabled(false);
 423         SetControlText(cbPortNumber, string.Empty);
 424         SetControlText(cbConnectedDevice, string.Empty);
 425         ActiveProcess = new UpdatePhysicalAddress(ref Lib, physicalAddress);
 426         ActiveProcess.EventHandler += ProcessEventHandler;
 427         (new Thread(ActiveProcess.Run)).Start();
 428       }
 429     }
 430
 431     public void UpdateConfigurationAsync()
 432     {
 433       if (!SuppressUpdates && ActiveProcess == null)
 434       {
 435         SetControlsEnabled(false);
 436         ActiveProcess = new UpdateConfiguration(ref Lib, Config);
 437         ActiveProcess.EventHandler += ProcessEventHandler;
 438         (new Thread(ActiveProcess.Run)).Start();
 439       }
 440     }
 441
 442     public void SendImageViewOn(CecLogicalAddress address)
 443     {
 444       if (!SuppressUpdates && ActiveProcess == null)
 445       {
 446         SetControlsEnabled(false);
 447         ActiveProcess = new SendImageViewOn(ref Lib, address);
 448         ActiveProcess.EventHandler += ProcessEventHandler;
 449         (new Thread(ActiveProcess.Run)).Start();
 450       }
 451     }
 452
 453     public void ActivateSource(CecLogicalAddress address)
 454     {
 455       if (!SuppressUpdates && ActiveProcess == null)
 456       {
 457         SetControlsEnabled(false);
 458         ActiveProcess = new SendActivateSource(ref Lib, address);
 459         ActiveProcess.EventHandler += ProcessEventHandler;
 460         (new Thread(ActiveProcess.Run)).Start();
 461       }
 462     }
 463
 464     public void SendStandby(CecLogicalAddress address)
 465     {
 466       if (!SuppressUpdates && ActiveProcess == null)
 467       {
 468         SetControlsEnabled(false);
 469         ActiveProcess = new SendStandby(ref Lib, address);
 470         ActiveProcess.EventHandler += ProcessEventHandler;
 471         (new Thread(ActiveProcess.Run)).Start();
 472       }
 473     }
 474
 475     public void ShowDeviceInfo(CecLogicalAddress address)
 476     {
 477       if (!SuppressUpdates && ActiveProcess == null)
 478       {
 479         SetControlsEnabled(false);
 480         ActiveProcess = new ShowDeviceInfo(this, ref Lib, address);
 481         ActiveProcess.EventHandler += ProcessEventHandler;
 482         (new Thread(ActiveProcess.Run)).Start();
 483       }
 484     }
 485     #endregion
 486
 487     #region Configuration tab
 488     private void cbOverrideAddress_CheckedChanged(object sender, EventArgs e)
 489     {
 490       SetControlEnabled(tbPhysicalAddress, ((CheckBox)sender).Checked);
 491       SetControlEnabled(cbPortNumber, !((CheckBox)sender).Checked);
 492       SetControlEnabled(cbConnectedDevice, !((CheckBox)sender).Checked && cbConnectedDevice.Items.Count > 1);
 493     }
 494
 495     private void tbPhysicalAddress_TextChanged(object sender, EventArgs e)
 496     {
 497       if (tbPhysicalAddress.Text.Length != 4 ||
 498           cbOverrideAddress.Checked)
 499         return;
 500       ushort physicalAddress = 0;
 501       if (!ushort.TryParse(tbPhysicalAddress.Text, NumberStyles.AllowHexSpecifier, null, out physicalAddress))
 502         return;
 503
 504       SetPhysicalAddress(physicalAddress);
 505     }
 506
 507     private void UpdateSelectedDevice()
 508     {
 509       if (HasAVRDevice)
 510         SetComboBoxItems(cbConnectedDevice, Config.BaseDevice == CecLogicalAddress.AudioSystem ? AVRVendorString : TVVendorString, new object[] { TVVendorString, AVRVendorString });
 511       else
 512         SetComboBoxItems(cbConnectedDevice, TVVendorString, new object[] { TVVendorString });
 513     }
 514
 515     public void SetConnectedDevice(CecLogicalAddress address, int portnumber)
 516     {
 517       if (!SuppressUpdates && ActiveProcess == null)
 518       {
 519         SetControlsEnabled(false);
 520         ActiveProcess = new UpdateConnectedDevice(ref Lib, address, portnumber);
 521         ActiveProcess.EventHandler += ProcessEventHandler;
 522         (new Thread(ActiveProcess.Run)).Start();
 523       }
 524     }
 525
 526     private void connectedDevice_SelectedIndexChanged(object sender, EventArgs e)
 527     {
 528       SetConnectedDevice(SelectedConnectedDevice, SelectedPortNumber);
 529     }
 530
 531     private void bCancel_Click(object sender, EventArgs e)
 532     {
 533       Dispose();
 534     }
 535
 536     private void bSave_Click(object sender, EventArgs e)
 537     {
 538       SetControlsEnabled(false);
 539
 540       Config.UseTVMenuLanguage = cbUseTVMenuLanguage.Checked;
 541       Config.ActivateSource = cbActivateSource.Checked;
 542       Config.PowerOffScreensaver = cbPowerOffScreensaver.Checked;
 543       Config.PowerOffOnStandby = cbPowerOffOnStandby.Checked;
 544       Config.SendInactiveSource = cbSendInactiveSource.Checked;
 545       Config.WakeDevices = WakeDevices;
 546       Config.PowerOffDevices = PowerOffDevices;
 547
 548       if (!Lib.CanPersistConfiguration())
 549       {
 550         if (ActiveProcess == null)
 551         {
 552           SetControlsEnabled(false);
 553           string xbmcDir = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + @"\XBMC\userdata\peripheral_data";
 554           string defaultDir = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
 555
 556           SaveFileDialog dialog = new SaveFileDialog()
 557           {
 558             Title = "Where do you want to store the settings?",
 559             InitialDirectory = Directory.Exists(xbmcDir) ? xbmcDir : defaultDir,
 560             FileName = "usb_2548_1001.xml",
 561             Filter = "xml files (*.xml)|*.xml|All files (*.*)|*.*",
 562             FilterIndex = 1
 563           };
 564
 565           if (dialog.ShowDialog() == DialogResult.OK)
 566           {
 567             FileStream fs = null;
 568             string error = string.Empty;
 569             try
 570             {
 571               fs = (FileStream)dialog.OpenFile();
 572             }
 573             catch (Exception ex)
 574             {
 575               error = ex.Message;
 576             }
 577             if (fs == null)
 578             {
 579               MessageBox.Show("Cannot open '" + dialog.FileName + "' for writing" + (error.Length > 0 ? ": " + error : string.Empty ), "Pulse-Eight USB-CEC Adapter", MessageBoxButtons.OK, MessageBoxIcon.Error);
 580             }
 581             else
 582             {
 583               StreamWriter writer = new StreamWriter(fs);
 584               StringBuilder output = new StringBuilder();
 585               output.AppendLine("<settings>");
 586               output.AppendLine("<setting id=\"cec_hdmi_port\" value=\"" + Config.HDMIPort + "\" />");
 587               output.AppendLine("<setting id=\"connected_device\" value=\"" + (Config.BaseDevice == CecLogicalAddress.AudioSystem ? 5 : 0) + "\" />");
 588               output.AppendLine("<setting id=\"cec_power_on_startup\" value=\"" + (Config.ActivateSource ? 1 : 0) + "\" />");
 589               output.AppendLine("<setting id=\"cec_power_off_shutdown\" value=\"" + (Config.PowerOffDevices.IsSet(CecLogicalAddress.Broadcast) ? 1 : 0) + "\" />");
 590               output.AppendLine("<setting id=\"cec_standby_screensaver\" value=\"" + (Config.PowerOffScreensaver ? 1 : 0) + "\" />");
 591               output.AppendLine("<setting id=\"standby_pc_on_tv_standby\" value=\"" + (Config.PowerOffOnStandby ? 1 : 0) + "\" />");
 592               output.AppendLine("<setting id=\"use_tv_menu_language\" value=\"" + (Config.UseTVMenuLanguage ? 1 : 0) + "\" />");
 593               output.AppendLine("<setting id=\"enabled\" value=\"1\" />");
 594               output.AppendLine("<setting id=\"port\" value=\"\" />");
 595
 596               // only supported by 1.5.0+ clients
 597               output.AppendLine("<!-- the following lines are only supported by v1.5.0+ clients -->");
 598               output.AppendLine("<setting id=\"activate_source\" value=\"" + (Config.ActivateSource ? 1 : 0) + "\" />");
 599               output.AppendLine("<setting id=\"physical_address\" value=\"" + string.Format("{0,4:X}", cbOverrideAddress.Checked ? Config.PhysicalAddress : 0).Trim() + "\" />");
 600               output.AppendLine("<setting id=\"device_type\" value=\"" + (int)Config.DeviceTypes.Types[0] + "\" />");
 601               output.AppendLine("<setting id=\"tv_vendor\" value=\"" + string.Format("{0,6:X}", (int)Config.TvVendor).Trim() + "\" />");
 602
 603               output.Append("<setting id=\"wake_devices\" value=\"");
 604               StringBuilder strWakeDevices = new StringBuilder();
 605               foreach (CecLogicalAddress addr in Config.WakeDevices.Addresses)
 606                 if (addr != CecLogicalAddress.Unknown)
 607                   strWakeDevices.Append(" " + (int)addr);
 608               output.Append(strWakeDevices.ToString().Trim());
 609               output.AppendLine("\" />");
 610
 611               output.Append("<setting id=\"standby_devices\" value=\"");
 612               StringBuilder strSleepDevices = new StringBuilder();
 613               foreach (CecLogicalAddress addr in Config.PowerOffDevices.Addresses)
 614                 if (addr != CecLogicalAddress.Unknown)
 615                   strSleepDevices.Append(" " + (int)addr);
 616               output.Append(strSleepDevices.ToString().Trim());
 617               output.AppendLine("\" />");
 618
 619               // only supported by 1.5.1+ clients
 620               output.AppendLine("<!-- the following lines are only supported by v1.5.1+ clients -->");
 621               output.AppendLine("<setting id=\"send_inactive_source\" value=\"" + (Config.SendInactiveSource ? 1 : 0) + "\" />");
 622
 623               output.AppendLine("</settings>");
 624               writer.Write(output.ToString());
 625               writer.Close();
 626               fs.Close();
 627               fs.Dispose();
 628               MessageBox.Show("Settings are stored.", "Pulse-Eight USB-CEC Adapter", MessageBoxButtons.OK, MessageBoxIcon.Information);
 629             }
 630           }
 631           SetControlsEnabled(true);
 632         }
 633       }
 634       else
 635       {
 636         if (!Lib.PersistConfiguration(Config))
 637           MessageBox.Show("Could not persist the new settings.", "Pulse-Eight USB-CEC Adapter", MessageBoxButtons.OK, MessageBoxIcon.Error);
 638         else
 639           MessageBox.Show("Settings are stored.", "Pulse-Eight USB-CEC Adapter", MessageBoxButtons.OK, MessageBoxIcon.Information);
 640       }
 641       SetControlsEnabled(true);
 642     }
 643
 644     private void bReloadConfig_Click(object sender, EventArgs e)
 645     {
 646       if (Lib.CanPersistConfiguration())
 647       {
 648         Lib.GetCurrentConfiguration(Config);
 649         ConfigurationChanged(Config);
 650       }
 651       else
 652       {
 653         ReloadXmlConfiguration();
 654       }
 655     }
 656
 657     private void cbVendorOverride_CheckedChanged(object sender, EventArgs e)
 658     {
 659       if (cbVendorOverride.Checked)
 660       {
 661         cbVendorId.Enabled = true;
 662         switch (cbVendorId.Text)
 663         {
 664           case "LG":
 665             Config.TvVendor = CecVendorId.LG;
 666             break;
 667           case "Onkyo":
 668             Config.TvVendor = CecVendorId.Onkyo;
 669             break;
 670           case "Panasonic":
 671             Config.TvVendor = CecVendorId.Panasonic;
 672             break;
 673           case "Philips":
 674             Config.TvVendor = CecVendorId.Philips;
 675             break;
 676           case "Pioneer":
 677             Config.TvVendor = CecVendorId.Pioneer;
 678             break;
 679           case "Samsung":
 680             Config.TvVendor = CecVendorId.Samsung;
 681             break;
 682           case "Sony":
 683             Config.TvVendor = CecVendorId.Sony;
 684             break;
 685           case "Yamaha":
 686             Config.TvVendor = CecVendorId.Yamaha;
 687             break;
 688           default:
 689             Config.TvVendor = CecVendorId.Unknown;
 690             break;
 691         }
 692       }
 693       else
 694       {
 695         cbVendorId.Enabled = false;
 696         Config.TvVendor = CecVendorId.Unknown;
 697       }
 698     }
 699
 700     private void cbDeviceType_SelectedIndexChanged(object sender, EventArgs e)
 701     {
 702       CecDeviceType type = SelectedDeviceType;
 703       if (type != Config.DeviceTypes.Types[0])
 704       {
 705         Config.DeviceTypes.Types[0] = type;
 706         if (!DeviceChangeWarningDisplayed)
 707         {
 708           DeviceChangeWarningDisplayed = true;
 709           MessageBox.Show("You have changed the device type. Save the configuration, and restart the application to use the new setting.", "Pulse-Eight USB-CEC Adapter", MessageBoxButtons.OK, MessageBoxIcon.Warning);
 710         }
 711       }
 712     }
 713     #endregion
 714
 715     #region Key configuration tab
 716     delegate void SelectKeypressRowCallback(CecKeypress key);
 717     private void SelectKeypressRow(CecKeypress key)
 718     {
 719       if (dgButtons.InvokeRequired)
 720       {
 721         SelectKeypressRowCallback d = SelectKeypressRow;
 722         try
 723         {
 724           Invoke(d, new object[] { key });
 725         }
 726         catch (Exception) { }
 727       }
 728       else
 729       {
 730         int rowIndex = -1;
 731         foreach (DataGridViewRow row in dgButtons.Rows)
 732         {
 733           CecButtonConfigItem item = row.DataBoundItem as CecButtonConfigItem;
 734           if (item != null && item.Key.Keycode == key.Keycode)
 735           {
 736             rowIndex = row.Index;
 737             row.Selected = true;
 738             item.Enabled = true;
 739           }
 740           else
 741           {
 742             row.Selected = false;
 743           }
 744         }
 745         if (rowIndex > -1)
 746           dgButtons.FirstDisplayedScrollingRowIndex = rowIndex;
 747       }
 748     }
 749
 750     private void dataGridView1_CellFormatting(object sender, DataGridViewCellFormattingEventArgs e)
 751     {
 752       DataGridView grid = sender as DataGridView;
 753       CecButtonConfigItem data = grid.Rows[e.RowIndex].DataBoundItem as CecButtonConfigItem;
 754       if (data == null || !data.Enabled)
 755         e.CellStyle.ForeColor = Color.Gray;
 756     }
 757     #endregion
 758
 759     #region CEC Tester tab
 760     public void CheckActiveDevices()
 761     {
 762       CecLogicalAddresses activeDevices = Lib.GetActiveDevices();
 763       List<string> deviceList = new List<string>();
 764       foreach (CecLogicalAddress activeDevice in activeDevices.Addresses)
 765       {
 766         if (activeDevice != CecLogicalAddress.Unknown)
 767           deviceList.Add(string.Format("{0,1:X} : {1}", (int)activeDevice, Lib.ToString(activeDevice)));
 768       }
 769       deviceList.Add(string.Format("{0,1:X} : {1}", (int)CecLogicalAddress.Broadcast, Lib.ToString(CecLogicalAddress.Broadcast)));
 770
 771       SetActiveDevices(deviceList.ToArray());
 772     }
 773
 774     delegate void SetActiveDevicesCallback(string[] activeDevices);
 775     private void SetActiveDevices(string[] activeDevices)
 776     {
 777       if (cbCommandDestination.InvokeRequired)
 778       {
 779         SetActiveDevicesCallback d = SetActiveDevices;
 780         try
 781         {
 782           Invoke(d, new object[] { activeDevices });
 783         }
 784         catch (Exception) { }
 785       }
 786       else
 787       {
 788         cbCommandDestination.Items.Clear();
 789         foreach (string item in activeDevices)
 790           cbCommandDestination.Items.Add(item);
 791       }
 792     }
 793
 794     delegate CecLogicalAddress GetTargetDeviceCallback();
 795     private CecLogicalAddress GetTargetDevice()
 796     {
 797       if (cbCommandDestination.InvokeRequired)
 798       {
 799         GetTargetDeviceCallback d = GetTargetDevice;
 800         CecLogicalAddress retval = CecLogicalAddress.Unknown;
 801         try
 802         {
 803           retval = (CecLogicalAddress)Invoke(d, new object[] { });
 804         }
 805         catch (Exception) { }
 806         return retval;
 807       }
 808
 809       return GetLogicalAddressFromString(cbCommandDestination.Text);
 810     }
 811
 812     private CecLogicalAddress GetLogicalAddressFromString(string name)
 813     {
 814       switch (name.Substring(0, 1).ToLower())
 815       {
 816         case "0":
 817           return CecLogicalAddress.Tv;
 818         case "1":
 819           return CecLogicalAddress.RecordingDevice1;
 820         case "2":
 821           return CecLogicalAddress.RecordingDevice2;
 822         case "3":
 823           return CecLogicalAddress.Tuner1;
 824         case "4":
 825           return CecLogicalAddress.PlaybackDevice1;
 826         case "5":
 827           return CecLogicalAddress.AudioSystem;
 828         case "6":
 829           return CecLogicalAddress.Tuner2;
 830         case "7":
 831           return CecLogicalAddress.Tuner3;
 832         case "8":
 833           return CecLogicalAddress.PlaybackDevice2;
 834         case "9":
 835           return CecLogicalAddress.RecordingDevice3;
 836         case "a":
 837           return CecLogicalAddress.Tuner4;
 838         case "b":
 839           return CecLogicalAddress.PlaybackDevice3;
 840         case "c":
 841           return CecLogicalAddress.Reserved1;
 842         case "d":
 843           return CecLogicalAddress.Reserved2;
 844         case "e":
 845           return CecLogicalAddress.FreeUse;
 846         case "f":
 847           return CecLogicalAddress.Broadcast;
 848         default:
 849           return CecLogicalAddress.Unknown;
 850       }
 851     }
 852
 853     private void bSendImageViewOn_Click(object sender, EventArgs e)
 854     {
 855       SendImageViewOn(GetTargetDevice());
 856     }
 857
 858     private void bStandby_Click(object sender, EventArgs e)
 859     {
 860       SendStandby(GetTargetDevice());
 861     }
 862
 863     private void bScan_Click(object sender, EventArgs e)
 864     {
 865       ShowDeviceInfo(GetTargetDevice());
 866     }
 867
 868     private void bActivateSource_Click(object sender, EventArgs e)
 869     {
 870       ActivateSource(GetTargetDevice());
 871     }
 872
 873     private void cbCommandDestination_SelectedIndexChanged(object sender, EventArgs e)
 874     {
 875       bool enableVolumeButtons = (GetTargetDevice() == CecLogicalAddress.AudioSystem);
 876       bVolUp.Enabled = enableVolumeButtons;
 877       bVolDown.Enabled = enableVolumeButtons;
 878       bMute.Enabled = enableVolumeButtons;
 879       bActivateSource.Enabled = (GetTargetDevice() != CecLogicalAddress.Broadcast);
 880       bScan.Enabled = (GetTargetDevice() != CecLogicalAddress.Broadcast);
 881     }
 882
 883     private void bVolUp_Click(object sender, EventArgs e)
 884     {
 885       SetControlsEnabled(false);
 886       Lib.VolumeUp(true);
 887       SetControlsEnabled(true);
 888     }
 889
 890     private void bVolDown_Click(object sender, EventArgs e)
 891     {
 892       SetControlsEnabled(false);
 893       Lib.VolumeDown(true);
 894       SetControlsEnabled(true);
 895     }
 896
 897     private void bMute_Click(object sender, EventArgs e)
 898     {
 899       SetControlsEnabled(false);
 900       Lib.MuteAudio(true);
 901       SetControlsEnabled(true);
 902     }
 903
 904     private void bRescanDevices_Click(object sender, EventArgs e)
 905     {
 906       if (!SuppressUpdates && ActiveProcess == null)
 907       {
 908         SetControlsEnabled(false);
 909         ActiveProcess = new RescanDevices(ref Lib);
 910         ActiveProcess.EventHandler += ProcessEventHandler;
 911         (new Thread(ActiveProcess.Run)).Start();
 912       }
 913     }
 914     #endregion
 915
 916     #region Log tab
 917     delegate void UpdateLogCallback();
 918     private void UpdateLog()
 919     {
 920       if (tbLog.InvokeRequired)
 921       {
 922         UpdateLogCallback d = UpdateLog;
 923         try
 924         {
 925           Invoke(d, new object[] { });
 926         }
 927         catch (Exception) { }
 928       }
 929       else
 930       {
 931         tbLog.Text = Log;
 932         tbLog.Select(tbLog.Text.Length, 0);
 933         tbLog.ScrollToCaret();
 934       }
 935     }
 936
 937     private void AddLogMessage(CecLogMessage message)
 938     {
 939       string strLevel = "";
 940       bool display = false;
 941       switch (message.Level)
 942       {
 943         case CecLogLevel.Error:
 944           strLevel = "ERROR:   ";
 945           display = cbLogError.Checked;
 946           break;
 947         case CecLogLevel.Warning:
 948           strLevel = "WARNING: ";
 949           display = cbLogWarning.Checked;
 950           break;
 951         case CecLogLevel.Notice:
 952           strLevel = "NOTICE:  ";
 953           display = cbLogNotice.Checked;
 954           break;
 955         case CecLogLevel.Traffic:
 956           strLevel = "TRAFFIC: ";
 957           display = cbLogTraffic.Checked;
 958           break;
 959         case CecLogLevel.Debug:
 960           strLevel = "DEBUG:   ";
 961           display = cbLogDebug.Checked;
 962           break;
 963         default:
 964           break;
 965       }
 966
 967       if (display)
 968       {
 969         string strLog = string.Format("{0} {1,16} {2}", strLevel, message.Time, message.Message) + System.Environment.NewLine;
 970         Log += strLog;
 971       }
 972
 973       if (SelectedTab == ConfigTab.Log)
 974         UpdateLog();
 975     }
 976
 977     private void bClearLog_Click(object sender, EventArgs e)
 978     {
 979       Log = string.Empty;
 980       UpdateLog();
 981     }
 982
 983     private void bSaveLog_Click(object sender, EventArgs e)
 984     {
 985       SaveFileDialog dialog = new SaveFileDialog()
 986       {
 987         Title = "Where do you want to store the log file?",
 988         InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
 989         FileName = "cec-log.txt",
 990         Filter = "txt files (*.txt)|*.txt|All files (*.*)|*.*",
 991         FilterIndex = 1
 992       };
 993
 994       if (dialog.ShowDialog() == DialogResult.OK)
 995       {
 996         FileStream fs = (FileStream)dialog.OpenFile();
 997         if (fs == null)
 998         {
 999           MessageBox.Show("Cannot open '" + dialog.FileName + "' for writing", "Pulse-Eight USB-CEC Adapter", MessageBoxButtons.OK, MessageBoxIcon.Error);
1000         }
1001         else
1002         {
1003           StreamWriter writer = new StreamWriter(fs);
1004           writer.Write(Log);
1005           writer.Close();
1006           fs.Close();
1007           fs.Dispose();
1008           MessageBox.Show("The log file was stored as '" + dialog.FileName + "'.", "Pulse-Eight USB-CEC Adapter", MessageBoxButtons.OK, MessageBoxIcon.Information);
1009         }
1010       }
1011     }
1012     #endregion
1013
1014     #region LibCecSharp callbacks
1015     public int ConfigurationChanged(LibCECConfiguration config)
1016     {
1017       Config = config;
1018       SetControlText(tbPhysicalAddress, string.Format("{0,4:X}", Config.PhysicalAddress));
1019       SetControlText(cbConnectedDevice, Config.BaseDevice == CecLogicalAddress.AudioSystem ? AVRVendorString : TVVendorString);
1020       SetControlText(cbPortNumber, Config.HDMIPort.ToString());
1021       switch (config.DeviceTypes.Types[0])
1022       {
1023         case CecDeviceType.RecordingDevice:
1024           SetControlText(cbDeviceType, "Recorder");
1025           break;
1026         case CecDeviceType.PlaybackDevice:
1027           SetControlText(cbDeviceType, "Player");
1028           break;
1029         case CecDeviceType.Tuner:
1030           SetControlText(cbDeviceType, "Tuner");
1031           break;
1032         default:
1033           SetControlText(cbDeviceType, "Recorder");
1034           break;
1035       }
1036       if (config.TvVendor != CecVendorId.Unknown)
1037       {
1038         SetCheckboxChecked(cbVendorOverride, true);
1039         SetControlText(cbVendorId, Lib.ToString(config.TvVendor));
1040       }
1041       else
1042       {
1043         SetCheckboxChecked(cbVendorOverride, false);
1044         SetControlText(cbVendorId, Lib.ToString(TVVendor));
1045       }
1046
1047       SetCheckboxChecked(cbUseTVMenuLanguage, Config.UseTVMenuLanguage);
1048       SetCheckboxChecked(cbActivateSource, Config.ActivateSource);
1049       SetCheckboxChecked(cbPowerOffScreensaver, Config.PowerOffScreensaver);
1050       SetCheckboxChecked(cbPowerOffOnStandby, Config.PowerOffOnStandby);
1051       SetCheckboxChecked(cbSendInactiveSource, Config.SendInactiveSource);
1052       UpdateSelectedDevice();
1053
1054       for (int iPtr = 0; iPtr < 15; iPtr++)
1055         SetCheckboxItemChecked(cbWakeDevices, iPtr, Config.WakeDevices.IsSet((CecLogicalAddress)iPtr));
1056       for (int iPtr = 0; iPtr < 15; iPtr++)
1057         SetCheckboxItemChecked(cbPowerOffDevices, iPtr, Config.PowerOffDevices.IsSet((CecLogicalAddress)iPtr));
1058
1059       SetControlText(this, "Pulse-Eight USB-CEC Adapter - libCEC " + Lib.ToString(Config.ServerVersion));
1060       return 1;
1061     }
1062
1063     public int ReceiveCommand(CecCommand command)
1064     {
1065       return 1;
1066     }
1067
1068     public int ReceiveKeypress(CecKeypress key)
1069     {
1070       SelectKeypressRow(key);
1071       return 1;
1072     }
1073
1074     public int ReceiveLogMessage(CecLogMessage message)
1075     {
1076       try
1077       {
1078         AddLogMessage(message);
1079       }
1080       catch (Exception) { }
1081       return 1;
1082     }
1083     #endregion
1084
1085     #region Class members
1086     public bool HasAVRDevice { get; private set; }
1087     #region TV Vendor
1088     private CecVendorId _tvVendor = CecVendorId.Unknown;
1089     public CecVendorId TVVendor
1090     {
1091       get { return _tvVendor;}
1092       private set { _tvVendor = value; }
1093     }
1094     public string TVVendorString
1095     {
1096       get
1097       {
1098         return TVVendor != CecVendorId.Unknown ?
1099           "Television (" + Lib.ToString(TVVendor) + ")" :
1100           "Television";
1101       }
1102     }
1103     #endregion
1104     #region AVR Vendor
1105     private CecVendorId _avrVendor = CecVendorId.Unknown;
1106     public CecVendorId AVRVendor
1107     {
1108       get { return _avrVendor; }
1109       private set { _avrVendor = value; }
1110     }
1111     public string AVRVendorString
1112     {
1113       get
1114       {
1115         return AVRVendor != CecVendorId.Unknown ?
1116           "AVR (" + Lib.ToString(AVRVendor) + ")" :
1117           "AVR";
1118       }
1119     }
1120     #endregion
1121     public CecLogicalAddress SelectedConnectedDevice
1122     {
1123       get
1124       {
1125         return (cbConnectedDevice.Text.Equals(AVRVendorString)) ? CecLogicalAddress.AudioSystem : CecLogicalAddress.Tv;
1126       }
1127     }
1128     public CecDeviceType SelectedDeviceType
1129     {
1130       get
1131       {
1132         switch (cbDeviceType.Text.ToLower())
1133         {
1134           case "player":
1135             return CecDeviceType.PlaybackDevice;
1136           case "tuner":
1137             return CecDeviceType.Tuner;
1138           default:
1139             return CecDeviceType.RecordingDevice;
1140         }
1141       }
1142     }
1143     public int SelectedPortNumber
1144     {
1145       get
1146       {
1147         int iPortNumber = 0;
1148         if (!int.TryParse(cbPortNumber.Text, out iPortNumber))
1149           iPortNumber = 1;
1150         return iPortNumber;
1151       }
1152     }
1153     protected LibCECConfiguration Config;
1154     protected LibCecSharp Lib;
1155     private CecCallbackWrapper Callbacks;
1156     private UpdateProcess ActiveProcess = null;
1157     private bool SuppressUpdates = true;
1158     private ConfigTab SelectedTab = ConfigTab.Configuration;
1159     private string Log = string.Empty;
1160     private DeviceInformation UpdatingInfoPanel = null;
1161     private bool DeviceChangeWarningDisplayed = false;
1162     public CecLogicalAddresses WakeDevices
1163     {
1164       get
1165       {
1166         CecLogicalAddresses addr = new CecLogicalAddresses();
1167         foreach (object item in cbWakeDevices.CheckedItems)
1168         {
1169           string c = item as string;
1170           addr.Set(GetLogicalAddressFromString(c));
1171         }
1172         return addr;
1173       }
1174     }
1175     public CecLogicalAddresses PowerOffDevices
1176     {
1177       get
1178       {
1179         CecLogicalAddresses addr = new CecLogicalAddresses();
1180         foreach (object item in cbPowerOffDevices.CheckedItems)
1181         {
1182           string c = item as string;
1183           addr.Set(GetLogicalAddressFromString(c));
1184         }
1185         return addr;
1186       }
1187     }
1188     #endregion
1189   }
1190
1191   /// <summary>
1192   /// A little wrapper that is needed because we already inherit form
1193   /// </summary>
1194   internal class CecCallbackWrapper : CecCallbackMethods
1195   {
1196     public CecCallbackWrapper(CecConfigGUI gui)
1197     {
1198       Gui = gui;
1199     }
1200
1201     public override int ReceiveCommand(CecCommand command)
1202     {
1203       return Gui.ReceiveCommand(command);
1204     }
1205
1206     public override int ReceiveKeypress(CecKeypress key)
1207     {
1208       return Gui.ReceiveKeypress(key);
1209     }
1210
1211     public override int ReceiveLogMessage(CecLogMessage message)
1212     {
1213       return Gui.ReceiveLogMessage(message);
1214     }
1215
1216     public override int ConfigurationChanged(LibCECConfiguration config)
1217     {
1218       return Gui.ConfigurationChanged(config);
1219     }
1220
1221     private CecConfigGUI Gui;
1222   }
1223 }