[deb_libcec.git] / src / cec-config-gui / CecConfigGUI.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Threading;
using CecSharp;
using CecConfigGui.actions;
using System.Globalization;
using System.IO;

namespace CecConfigGui
{
  public partial class CecConfigGUI : Form
  {
    public CecConfigGUI()
    {
      Config = new LibCECConfiguration();
      Config.DeviceTypes.Types[0] = CecDeviceType.RecordingDevice;
      Config.DeviceName = "CEC Config";
      Config.GetSettingsFromROM = true;
      Config.ClientVersion = CecClientVersion.Version1_5_0;
      Callbacks = new CecCallbackWrapper(this);
      Config.SetCallbacks(Callbacks);

      InitializeComponent();
      Lib = new LibCecSharp(Config);

      ActiveProcess = new ConnectToDevice(ref Lib);
      ActiveProcess.EventHandler += new EventHandler<UpdateEvent>(ProcessEventHandler);
      (new Thread(new ThreadStart(ActiveProcess.Run))).Start();
    }

    public int ReceiveCommand(CecCommand command)
    {
      return 1;
    }

    public int ReceiveKeypress(CecKeypress key)
    {
      return 1;
    }

    delegate void AddLogMessageCallback(CecLogMessage message);
    private void AddLogMessage(CecLogMessage message)
    {
      if (tbLog.InvokeRequired)
      {
        AddLogMessageCallback d = new AddLogMessageCallback(AddLogMessage);
        try
        {
          this.Invoke(d, new object[] { message });
        }
        catch (Exception) { }
      }
      else
      {
        if (((int)message.Level & LogLevel) == (int)message.Level)
        {
          string strLevel = "";
          switch (message.Level)
          {
            case CecLogLevel.Error:
              strLevel = "ERROR:   ";
              break;
            case CecLogLevel.Warning:
              strLevel = "WARNING: ";
              break;
            case CecLogLevel.Notice:
              strLevel = "NOTICE:  ";
              break;
            case CecLogLevel.Traffic:
              strLevel = "TRAFFIC: ";
              break;
            case CecLogLevel.Debug:
              strLevel = "DEBUG:   ";
              break;
            default:
              break;
          }
          string strLog = string.Format("{0} {1,16} {2}", strLevel, message.Time, message.Message) + System.Environment.NewLine;
          tbLog.Text += strLog;
        }
      }
    }

    public int ReceiveLogMessage(CecLogMessage message)
    {
      AddLogMessage(message);
      return 1;
    }

    delegate void SetControlEnabledCallback(Control control, bool val);
    private void SetControlEnabled(Control control, bool val)
    {
      if (control.InvokeRequired)
      {
        SetControlEnabledCallback d = new SetControlEnabledCallback(SetControlEnabled);
        try
        {
          this.Invoke(d, new object[] { control, val });
        }
        catch (Exception) { }
      }
      else
      {
        control.Enabled = val;
      }
    }

    private void SetControlsEnabled(bool val)
    {
      SetControlEnabled(cbPortNumber, val);
      SetControlEnabled(cbConnectedDevice, val);
      SetControlEnabled(tbPhysicalAddress, val);
      SetControlEnabled(cbDeviceType, val);
      SetControlEnabled(cbUseTVMenuLanguage, val);
      SetControlEnabled(cbPowerOnStartup, val);
      SetControlEnabled(cbPowerOffShutdown, val);
      SetControlEnabled(cbPowerOffScreensaver, val);
      SetControlEnabled(cbPowerOffOnStandby, val);
      SetControlEnabled(bClose, val);
      SetControlEnabled(bSave, val);
    }

    delegate void SetControlTextCallback(Control control, string val);
    private void SetControlText(Control control, string val)
    {
      if (control.InvokeRequired)
      {
        SetControlTextCallback d = new SetControlTextCallback(SetControlText);
        try
        {
          this.Invoke(d, new object[] { control, val });
        }
        catch (Exception) { }
      }
      else
      {
        control.Text = val;
      }
    }

    delegate void SetCheckboxCheckedCallback(CheckBox control, bool val);
    private void SetCheckboxChecked(CheckBox control, bool val)
    {
      if (control.InvokeRequired)
      {
        SetCheckboxCheckedCallback d = new SetCheckboxCheckedCallback(SetCheckboxChecked);
        try
        {
          this.Invoke(d, new object[] { control, val });
        }
        catch (Exception) { }
      }
      else
      {
        control.Checked = val;
      }
    }

    delegate void SetProgressValueCallback(ProgressBar control, int val);
    private void SetProgressValue(ProgressBar control, int val)
    {
      if (control.InvokeRequired)
      {
        SetProgressValueCallback d = new SetProgressValueCallback(SetProgressValue);
        try
        {
          this.Invoke(d, new object[] { control, val });
        }
        catch (Exception) { }
      }
      else
      {
        control.Value = val;
      }
    }

    delegate void SetComboBoxItemsCallback(ComboBox control, string selectedText, object[] val);
    private void SetComboBoxItems(ComboBox control, string selectedText, object[] val)
    {
      if (control.InvokeRequired)
      {
        SetComboBoxItemsCallback d = new SetComboBoxItemsCallback(SetComboBoxItems);
        try
        {
          this.Invoke(d, new object[] { control, selectedText, val });
        }
        catch (Exception) { }
      }
      else
      {
        control.Items.Clear();
        control.Items.AddRange(val);
        control.Text = selectedText;
      }
    }

    private void ProcessEventHandler(object src, UpdateEvent updateEvent)
    {
      switch (updateEvent.Type)
      {
        case UpdateEventType.StatusText:
          SetControlText(lStatus, updateEvent.StringValue);
          break;
        case UpdateEventType.PhysicalAddress:
          Config.PhysicalAddress = (ushort)updateEvent.IntValue;
          SetControlText(tbPhysicalAddress, string.Format("{0,4:X}", updateEvent.IntValue));
          break;
        case UpdateEventType.ProgressBar:
          SetProgressValue(pProgress, updateEvent.IntValue);
          break;
        case UpdateEventType.TVVendorId:
          TVVendor = (CecVendorId)updateEvent.IntValue;
          UpdateSelectedDevice();
          break;
        case UpdateEventType.BaseDevicePhysicalAddress:
          SetControlText(lConnectedPhysicalAddress, string.Format("Address: {0,4:X}", updateEvent.IntValue));
          break;
        case UpdateEventType.BaseDevice:
          Config.BaseDevice = (CecLogicalAddress)updateEvent.IntValue;
          break;
        case UpdateEventType.HDMIPort:
          Config.HDMIPort = (byte)updateEvent.IntValue;
          break;
        case UpdateEventType.MenuLanguage:
          SetControlText(cbUseTVMenuLanguage, "Use the TV's language setting" + (updateEvent.StringValue.Length > 0 ? " (" + updateEvent.StringValue + ")" : ""));
          break;
        case UpdateEventType.HasAVRDevice:
          if (HasAVRDevice != updateEvent.BoolValue)
          {
            HasAVRDevice = updateEvent.BoolValue;
            UpdateSelectedDevice();
          }
          break;
        case UpdateEventType.AVRVendorId:
          AVRVendor = (CecVendorId)updateEvent.IntValue;
          UpdateSelectedDevice();
          break;
        case UpdateEventType.Configuration:
          Config = updateEvent.ConfigValue;
          SetControlText(tbPhysicalAddress, string.Format("{0,4:X}", Config.PhysicalAddress));
          SetControlText(cbConnectedDevice, Config.BaseDevice == CecLogicalAddress.AudioSystem ? AVRVendorString : TVVendorString);
          SetControlText(cbPortNumber, Config.HDMIPort.ToString());
          SetCheckboxChecked(cbUseTVMenuLanguage, Config.UseTVMenuLanguage);
          SetCheckboxChecked(cbPowerOnStartup, Config.PowerOnStartup);
          SetCheckboxChecked(cbPowerOffShutdown, Config.PowerOffShutdown);
          SetCheckboxChecked(cbPowerOffScreensaver, Config.PowerOffScreensaver);
          SetCheckboxChecked(cbPowerOffOnStandby, Config.PowerOffOnStandby);
          UpdateSelectedDevice();
          break;
        case UpdateEventType.ProcessCompleted:
          ActiveProcess = null;
          SetControlsEnabled(true);
          break;
      }
    }

    private void UpdateSelectedDevice()
    {
      if (HasAVRDevice)
        SetComboBoxItems(this.cbConnectedDevice, Config.BaseDevice == CecLogicalAddress.AudioSystem ? AVRVendorString : TVVendorString, new object[] { TVVendorString, AVRVendorString });
      else
        SetComboBoxItems(this.cbConnectedDevice, TVVendorString, new object[] { TVVendorString });
    }

    public string TVVendorString
    {
      get
      {
        return TVVendor != CecVendorId.Unknown ?
          "Television (" + Lib.ToString(TVVendor) + ")" :
          "Television";
      }
    }

    public string AVRVendorString
    {
      get
      {
        return AVRVendor != CecVendorId.Unknown ?
          "AVR (" + Lib.ToString(AVRVendor) + ")" :
          "AVR";
      }
    }

    protected bool HasAVRDevice;
    protected CecVendorId TVVendor = CecVendorId.Unknown;
    protected CecVendorId AVRVendor = CecVendorId.Unknown;
    protected CecLogicalAddress SelectedConnectedDevice = CecLogicalAddress.Unknown;
    protected int LogLevel = (int)CecLogLevel.All;

    protected LibCECConfiguration Config;
    protected LibCecSharp Lib;
    private CecCallbackWrapper Callbacks;
    private UpdateProcess ActiveProcess = null;

    private void connectedDevice_SelectedIndexChanged(object sender, EventArgs e)
    {
      if (ActiveProcess == null)
      {
        SetControlsEnabled(false);
        SelectedConnectedDevice = (this.cbConnectedDevice.Text.Equals(AVRVendorString)) ? CecLogicalAddress.AudioSystem : CecLogicalAddress.Tv;
        int iPortNumber = 0;
        if (!int.TryParse(cbPortNumber.Text, out iPortNumber))
          iPortNumber = 1;
        ActiveProcess = new UpdateConnectedDevice(ref Lib, cbConnectedDevice.Text.Equals(AVRVendorString) ? CecLogicalAddress.AudioSystem : CecLogicalAddress.Tv, iPortNumber);
        ActiveProcess.EventHandler += new EventHandler<UpdateEvent>(ProcessEventHandler);
        (new Thread(new ThreadStart(ActiveProcess.Run))).Start();
      }
    }

    private void bCancel_Click(object sender, EventArgs e)
    {
      this.Dispose();
    }

    private void bSave_Click(object sender, EventArgs e)
    {
      SetControlsEnabled(false);

      Config.UseTVMenuLanguage = cbUseTVMenuLanguage.Checked;
      Config.PowerOnStartup = cbPowerOnStartup.Checked;
      Config.PowerOffShutdown = cbPowerOffShutdown.Checked;
      Config.PowerOffScreensaver = cbPowerOffScreensaver.Checked;
      Config.PowerOffOnStandby = cbPowerOffOnStandby.Checked;

      if (!Lib.CanPersistConfiguration())
      {
        if (ActiveProcess == null)
        {
          SetControlsEnabled(false);
          string xbmcDir = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + @"\XBMC\userdata\peripheral_data";
          string defaultDir = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);

          SaveFileDialog dialog = new SaveFileDialog()
          {
            Title = "Where do you want to store the settings?",
            InitialDirectory = Directory.Exists(xbmcDir) ? xbmcDir : defaultDir,
            FileName = "usb_2548_1001.xml",
            Filter = "xml files (*.xml)|*.xml|All files (*.*)|*.*",
            FilterIndex = 1
          };

          if (dialog.ShowDialog() == DialogResult.OK)
          {
            FileStream fs = (FileStream)dialog.OpenFile();
            if (fs == null)
            {
              MessageBox.Show("Cannot open '" + dialog.FileName + "' for writing", "Pulse-Eight USB-CEC Adapter", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
            else
            {
              StreamWriter writer = new StreamWriter(fs);
              StringBuilder output = new StringBuilder();
              output.AppendLine("<settings>");
              output.AppendLine("<setting id=\"cec_hdmi_port\" value=\"" + Config.HDMIPort + "\" />");
              output.AppendLine("<setting id=\"connected_device\" value=\"" + (Config.BaseDevice == CecLogicalAddress.AudioSystem ? 5 : 1) + "\" />");
              output.AppendLine("<setting id=\"physical_address\" value=\"" + string.Format("{0,4:X}", Config.PhysicalAddress) + "\" />");
              output.AppendLine("<setting id=\"device_type\" value=\"" + (int)Config.DeviceTypes.Types[0] + "\" />");
              output.AppendLine("<setting id=\"cec_power_on_startup\" value=\"" + (Config.PowerOnStartup ? 1 : 0) + "\" />");
              output.AppendLine("<setting id=\"cec_power_off_shutdown\" value=\"" + (Config.PowerOffShutdown ? 1 : 0) + "\" />");
              output.AppendLine("<setting id=\"cec_standby_screensaver\" value=\"" + (Config.PowerOffScreensaver ? 1 : 0) + "\" />");
              output.AppendLine("<setting id=\"standby_pc_on_tv_standby\" value=\"" + (Config.PowerOffOnStandby ? 1 : 0) + "\" />");
              output.AppendLine("<setting id=\"use_tv_menu_language\" value=\"" + (Config.UseTVMenuLanguage ? 1 : 0) + "\" />");
              output.AppendLine("<setting id=\"enabled\" value=\"1\" />");
              output.AppendLine("<setting id=\"port\" value=\"\" />");
              output.AppendLine("</settings>");
              writer.Write(output.ToString());
              writer.Close();
              fs.Close();
              fs.Dispose();
              MessageBox.Show("Settings are stored.", "Pulse-Eight USB-CEC Adapter", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
          }
          SetControlsEnabled(true);
        }
      }
      else
      {
        if (!Lib.PersistConfiguration(Config))
          MessageBox.Show("Could not persist the new settings.", "Pulse-Eight USB-CEC Adapter", MessageBoxButtons.OK, MessageBoxIcon.Error);
        else
          MessageBox.Show("Settings are stored.", "Pulse-Eight USB-CEC Adapter", MessageBoxButtons.OK, MessageBoxIcon.Information);
      }
      SetControlsEnabled(true);
    }

    private void tbPhysicalAddress_TextChanged(object sender, EventArgs e)
    {
      if (ActiveProcess == null)
      {
        if (tbPhysicalAddress.Text.Length != 4)
          return;
        ushort physicalAddress = 0;
        if (!ushort.TryParse(tbPhysicalAddress.Text, NumberStyles.AllowHexSpecifier, null, out physicalAddress))
          return;
        SetControlsEnabled(false);
        SetControlText(cbPortNumber, string.Empty);
        SetControlText(cbConnectedDevice, string.Empty);
        ActiveProcess = new UpdatePhysicalAddress(ref Lib, physicalAddress);
        ActiveProcess.EventHandler += new EventHandler<UpdateEvent>(ProcessEventHandler);
        (new Thread(new ThreadStart(ActiveProcess.Run))).Start();
      }
    }
  }

  internal class CecCallbackWrapper : CecCallbackMethods
  {
    public CecCallbackWrapper(CecConfigGUI gui)
    {
      Gui = gui;
    }

    public override int ReceiveCommand(CecCommand command)
    {
      return Gui.ReceiveCommand(command);
    }

    public override int ReceiveKeypress(CecKeypress key)
    {
      return Gui.ReceiveKeypress(key);
    }

    public override int ReceiveLogMessage(CecLogMessage message)
    {
      return Gui.ReceiveLogMessage(message);
    }

    private CecConfigGUI Gui;
  }
}
Commit	Line	Data
	1	using System;
	2	using System.Collections.Generic;
	3	using System.ComponentModel;
	4	using System.Data;
	5	using System.Drawing;
	6	using System.Text;
	7	using System.Windows.Forms;
	8	using System.Threading;
	9	using CecSharp;
	10	using CecConfigGui.actions;
	11	using System.Globalization;
	12	using System.IO;
	13
	14	namespace CecConfigGui
	15	{
	16	public partial class CecConfigGUI : Form
	17	{
	18	public CecConfigGUI()
	19	{
	20	Config = new LibCECConfiguration();
	21	Config.DeviceTypes.Types[0] = CecDeviceType.RecordingDevice;
	22	Config.DeviceName = "CEC Config";
	23	Config.GetSettingsFromROM = true;
	24	Config.ClientVersion = CecClientVersion.Version1_5_0;
	25	Callbacks = new CecCallbackWrapper(this);
	26	Config.SetCallbacks(Callbacks);
	27
	28	InitializeComponent();
	29	Lib = new LibCecSharp(Config);
	30
	31	ActiveProcess = new ConnectToDevice(ref Lib);
	32	ActiveProcess.EventHandler += new EventHandler<UpdateEvent>(ProcessEventHandler);
	33	(new Thread(new ThreadStart(ActiveProcess.Run))).Start();
	34	}
	35
	36	public int ReceiveCommand(CecCommand command)
	37	{
	38	return 1;
	39	}
	40
	41	public int ReceiveKeypress(CecKeypress key)
	42	{
	43	return 1;
	44	}
	45
	46	delegate void AddLogMessageCallback(CecLogMessage message);
	47	private void AddLogMessage(CecLogMessage message)
	48	{
	49	if (tbLog.InvokeRequired)
	50	{
	51	AddLogMessageCallback d = new AddLogMessageCallback(AddLogMessage);
	52	try
	53	{
	54	this.Invoke(d, new object[] { message });
	55	}
	56	catch (Exception) { }
	57	}
	58	else
	59	{
	60	if (((int)message.Level & LogLevel) == (int)message.Level)
	61	{
	62	string strLevel = "";
	63	switch (message.Level)
	64	{
	65	case CecLogLevel.Error:
	66	strLevel = "ERROR: ";
	67	break;
	68	case CecLogLevel.Warning:
	69	strLevel = "WARNING: ";
	70	break;
	71	case CecLogLevel.Notice:
	72	strLevel = "NOTICE: ";
	73	break;
	74	case CecLogLevel.Traffic:
	75	strLevel = "TRAFFIC: ";
	76	break;
	77	case CecLogLevel.Debug:
	78	strLevel = "DEBUG: ";
	79	break;
	80	default:
	81	break;
	82	}
	83	string strLog = string.Format("{0} {1,16} {2}", strLevel, message.Time, message.Message) + System.Environment.NewLine;
	84	tbLog.Text += strLog;
	85	}
	86	}
	87	}
	88
	89	public int ReceiveLogMessage(CecLogMessage message)
	90	{
	91	AddLogMessage(message);
	92	return 1;
	93	}
	94
	95	delegate void SetControlEnabledCallback(Control control, bool val);
	96	private void SetControlEnabled(Control control, bool val)
	97	{
	98	if (control.InvokeRequired)
	99	{
	100	SetControlEnabledCallback d = new SetControlEnabledCallback(SetControlEnabled);
	101	try
	102	{
	103	this.Invoke(d, new object[] { control, val });
	104	}
	105	catch (Exception) { }
	106	}
	107	else
	108	{
	109	control.Enabled = val;
	110	}
	111	}
	112
	113	private void SetControlsEnabled(bool val)
	114	{
	115	SetControlEnabled(cbPortNumber, val);
	116	SetControlEnabled(cbConnectedDevice, val);
	117	SetControlEnabled(tbPhysicalAddress, val);
	118	SetControlEnabled(cbDeviceType, val);
	119	SetControlEnabled(cbUseTVMenuLanguage, val);
	120	SetControlEnabled(cbPowerOnStartup, val);
	121	SetControlEnabled(cbPowerOffShutdown, val);
	122	SetControlEnabled(cbPowerOffScreensaver, val);
	123	SetControlEnabled(cbPowerOffOnStandby, val);
	124	SetControlEnabled(bClose, val);
	125	SetControlEnabled(bSave, val);
	126	}
	127
	128	delegate void SetControlTextCallback(Control control, string val);
	129	private void SetControlText(Control control, string val)
	130	{
	131	if (control.InvokeRequired)
	132	{
	133	SetControlTextCallback d = new SetControlTextCallback(SetControlText);
	134	try
	135	{
	136	this.Invoke(d, new object[] { control, val });
	137	}
	138	catch (Exception) { }
	139	}
	140	else
	141	{
	142	control.Text = val;
	143	}
	144	}
	145
	146	delegate void SetCheckboxCheckedCallback(CheckBox control, bool val);
	147	private void SetCheckboxChecked(CheckBox control, bool val)
	148	{
	149	if (control.InvokeRequired)
	150	{
	151	SetCheckboxCheckedCallback d = new SetCheckboxCheckedCallback(SetCheckboxChecked);
	152	try
	153	{
	154	this.Invoke(d, new object[] { control, val });
	155	}
	156	catch (Exception) { }
	157	}
	158	else
	159	{
	160	control.Checked = val;
	161	}
	162	}
	163
	164	delegate void SetProgressValueCallback(ProgressBar control, int val);
	165	private void SetProgressValue(ProgressBar control, int val)
	166	{
	167	if (control.InvokeRequired)
	168	{
	169	SetProgressValueCallback d = new SetProgressValueCallback(SetProgressValue);
	170	try
	171	{
	172	this.Invoke(d, new object[] { control, val });
	173	}
	174	catch (Exception) { }
	175	}
	176	else
	177	{
	178	control.Value = val;
	179	}
	180	}
	181
	182	delegate void SetComboBoxItemsCallback(ComboBox control, string selectedText, object[] val);
	183	private void SetComboBoxItems(ComboBox control, string selectedText, object[] val)
	184	{
	185	if (control.InvokeRequired)
	186	{
	187	SetComboBoxItemsCallback d = new SetComboBoxItemsCallback(SetComboBoxItems);
	188	try
	189	{
	190	this.Invoke(d, new object[] { control, selectedText, val });
	191	}
	192	catch (Exception) { }
	193	}
	194	else
	195	{
	196	control.Items.Clear();
	197	control.Items.AddRange(val);
	198	control.Text = selectedText;
	199	}
	200	}
	201
	202	private void ProcessEventHandler(object src, UpdateEvent updateEvent)
	203	{
	204	switch (updateEvent.Type)
	205	{
	206	case UpdateEventType.StatusText:
	207	SetControlText(lStatus, updateEvent.StringValue);
	208	break;
	209	case UpdateEventType.PhysicalAddress:
	210	Config.PhysicalAddress = (ushort)updateEvent.IntValue;
	211	SetControlText(tbPhysicalAddress, string.Format("{0,4:X}", updateEvent.IntValue));
	212	break;
	213	case UpdateEventType.ProgressBar:
	214	SetProgressValue(pProgress, updateEvent.IntValue);
	215	break;
	216	case UpdateEventType.TVVendorId:
	217	TVVendor = (CecVendorId)updateEvent.IntValue;
	218	UpdateSelectedDevice();
	219	break;
	220	case UpdateEventType.BaseDevicePhysicalAddress:
	221	SetControlText(lConnectedPhysicalAddress, string.Format("Address: {0,4:X}", updateEvent.IntValue));
	222	break;
	223	case UpdateEventType.BaseDevice:
	224	Config.BaseDevice = (CecLogicalAddress)updateEvent.IntValue;
	225	break;
	226	case UpdateEventType.HDMIPort:
	227	Config.HDMIPort = (byte)updateEvent.IntValue;
	228	break;
	229	case UpdateEventType.MenuLanguage:
	230	SetControlText(cbUseTVMenuLanguage, "Use the TV's language setting" + (updateEvent.StringValue.Length > 0 ? " (" + updateEvent.StringValue + ")" : ""));
	231	break;
	232	case UpdateEventType.HasAVRDevice:
	233	if (HasAVRDevice != updateEvent.BoolValue)
	234	{
	235	HasAVRDevice = updateEvent.BoolValue;
	236	UpdateSelectedDevice();
	237	}
	238	break;
	239	case UpdateEventType.AVRVendorId:
	240	AVRVendor = (CecVendorId)updateEvent.IntValue;
	241	UpdateSelectedDevice();
	242	break;
	243	case UpdateEventType.Configuration:
	244	Config = updateEvent.ConfigValue;
	245	SetControlText(tbPhysicalAddress, string.Format("{0,4:X}", Config.PhysicalAddress));
	246	SetControlText(cbConnectedDevice, Config.BaseDevice == CecLogicalAddress.AudioSystem ? AVRVendorString : TVVendorString);
	247	SetControlText(cbPortNumber, Config.HDMIPort.ToString());
	248	SetCheckboxChecked(cbUseTVMenuLanguage, Config.UseTVMenuLanguage);
	249	SetCheckboxChecked(cbPowerOnStartup, Config.PowerOnStartup);
	250	SetCheckboxChecked(cbPowerOffShutdown, Config.PowerOffShutdown);
	251	SetCheckboxChecked(cbPowerOffScreensaver, Config.PowerOffScreensaver);
	252	SetCheckboxChecked(cbPowerOffOnStandby, Config.PowerOffOnStandby);
	253	UpdateSelectedDevice();
	254	break;
	255	case UpdateEventType.ProcessCompleted:
	256	ActiveProcess = null;
	257	SetControlsEnabled(true);
	258	break;
	259	}
	260	}
	261
	262	private void UpdateSelectedDevice()
	263	{
	264	if (HasAVRDevice)
	265	SetComboBoxItems(this.cbConnectedDevice, Config.BaseDevice == CecLogicalAddress.AudioSystem ? AVRVendorString : TVVendorString, new object[] { TVVendorString, AVRVendorString });
	266	else
	267	SetComboBoxItems(this.cbConnectedDevice, TVVendorString, new object[] { TVVendorString });
	268	}
	269
	270	public string TVVendorString
	271	{
	272	get
	273	{
	274	return TVVendor != CecVendorId.Unknown ?
	275	"Television (" + Lib.ToString(TVVendor) + ")" :
	276	"Television";
	277	}
	278	}
	279
	280	public string AVRVendorString
	281	{
	282	get
	283	{
	284	return AVRVendor != CecVendorId.Unknown ?
	285	"AVR (" + Lib.ToString(AVRVendor) + ")" :
	286	"AVR";
	287	}
	288	}
	289
	290	protected bool HasAVRDevice;
	291	protected CecVendorId TVVendor = CecVendorId.Unknown;
	292	protected CecVendorId AVRVendor = CecVendorId.Unknown;
	293	protected CecLogicalAddress SelectedConnectedDevice = CecLogicalAddress.Unknown;
	294	protected int LogLevel = (int)CecLogLevel.All;
	295
	296	protected LibCECConfiguration Config;
	297	protected LibCecSharp Lib;
	298	private CecCallbackWrapper Callbacks;
	299	private UpdateProcess ActiveProcess = null;
	300
	301	private void connectedDevice_SelectedIndexChanged(object sender, EventArgs e)
	302	{
	303	if (ActiveProcess == null)
	304	{
	305	SetControlsEnabled(false);
	306	SelectedConnectedDevice = (this.cbConnectedDevice.Text.Equals(AVRVendorString)) ? CecLogicalAddress.AudioSystem : CecLogicalAddress.Tv;
	307	int iPortNumber = 0;
	308	if (!int.TryParse(cbPortNumber.Text, out iPortNumber))
	309	iPortNumber = 1;
	310	ActiveProcess = new UpdateConnectedDevice(ref Lib, cbConnectedDevice.Text.Equals(AVRVendorString) ? CecLogicalAddress.AudioSystem : CecLogicalAddress.Tv, iPortNumber);
	311	ActiveProcess.EventHandler += new EventHandler<UpdateEvent>(ProcessEventHandler);
	312	(new Thread(new ThreadStart(ActiveProcess.Run))).Start();
	313	}
	314	}
	315
	316	private void bCancel_Click(object sender, EventArgs e)
	317	{
	318	this.Dispose();
	319	}
	320
	321	private void bSave_Click(object sender, EventArgs e)
	322	{
	323	SetControlsEnabled(false);
	324
	325	Config.UseTVMenuLanguage = cbUseTVMenuLanguage.Checked;
	326	Config.PowerOnStartup = cbPowerOnStartup.Checked;
	327	Config.PowerOffShutdown = cbPowerOffShutdown.Checked;
	328	Config.PowerOffScreensaver = cbPowerOffScreensaver.Checked;
	329	Config.PowerOffOnStandby = cbPowerOffOnStandby.Checked;
	330
	331	if (!Lib.CanPersistConfiguration())
	332	{
	333	if (ActiveProcess == null)
	334	{
	335	SetControlsEnabled(false);
	336	string xbmcDir = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + @"\XBMC\userdata\peripheral_data";
	337	string defaultDir = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
	338
	339	SaveFileDialog dialog = new SaveFileDialog()
	340	{
	341	Title = "Where do you want to store the settings?",
	342	InitialDirectory = Directory.Exists(xbmcDir) ? xbmcDir : defaultDir,
	343	FileName = "usb_2548_1001.xml",
	344	Filter = "xml files (.xml)\|.xml\|All files (.)\|.",
	345	FilterIndex = 1
	346	};
	347
	348	if (dialog.ShowDialog() == DialogResult.OK)
	349	{
	350	FileStream fs = (FileStream)dialog.OpenFile();
	351	if (fs == null)
	352	{
	353	MessageBox.Show("Cannot open '" + dialog.FileName + "' for writing", "Pulse-Eight USB-CEC Adapter", MessageBoxButtons.OK, MessageBoxIcon.Error);
	354	}
	355	else
	356	{
	357	StreamWriter writer = new StreamWriter(fs);
	358	StringBuilder output = new StringBuilder();
	359	output.AppendLine("<settings>");
	360	output.AppendLine("<setting id=\"cec_hdmi_port\" value=\"" + Config.HDMIPort + "\" />");
	361	output.AppendLine("<setting id=\"connected_device\" value=\"" + (Config.BaseDevice == CecLogicalAddress.AudioSystem ? 5 : 1) + "\" />");
	362	output.AppendLine("<setting id=\"physical_address\" value=\"" + string.Format("{0,4:X}", Config.PhysicalAddress) + "\" />");
	363	output.AppendLine("<setting id=\"device_type\" value=\"" + (int)Config.DeviceTypes.Types[0] + "\" />");
	364	output.AppendLine("<setting id=\"cec_power_on_startup\" value=\"" + (Config.PowerOnStartup ? 1 : 0) + "\" />");
	365	output.AppendLine("<setting id=\"cec_power_off_shutdown\" value=\"" + (Config.PowerOffShutdown ? 1 : 0) + "\" />");
	366	output.AppendLine("<setting id=\"cec_standby_screensaver\" value=\"" + (Config.PowerOffScreensaver ? 1 : 0) + "\" />");
	367	output.AppendLine("<setting id=\"standby_pc_on_tv_standby\" value=\"" + (Config.PowerOffOnStandby ? 1 : 0) + "\" />");
	368	output.AppendLine("<setting id=\"use_tv_menu_language\" value=\"" + (Config.UseTVMenuLanguage ? 1 : 0) + "\" />");
	369	output.AppendLine("<setting id=\"enabled\" value=\"1\" />");
	370	output.AppendLine("<setting id=\"port\" value=\"\" />");
	371	output.AppendLine("</settings>");
	372	writer.Write(output.ToString());
	373	writer.Close();
	374	fs.Close();
	375	fs.Dispose();
	376	MessageBox.Show("Settings are stored.", "Pulse-Eight USB-CEC Adapter", MessageBoxButtons.OK, MessageBoxIcon.Information);
	377	}
	378	}
	379	SetControlsEnabled(true);
	380	}
	381	}
	382	else
	383	{
	384	if (!Lib.PersistConfiguration(Config))
	385	MessageBox.Show("Could not persist the new settings.", "Pulse-Eight USB-CEC Adapter", MessageBoxButtons.OK, MessageBoxIcon.Error);
	386	else
	387	MessageBox.Show("Settings are stored.", "Pulse-Eight USB-CEC Adapter", MessageBoxButtons.OK, MessageBoxIcon.Information);
	388	}
	389	SetControlsEnabled(true);
	390	}
	391
	392	private void tbPhysicalAddress_TextChanged(object sender, EventArgs e)
	393	{
	394	if (ActiveProcess == null)
	395	{
	396	if (tbPhysicalAddress.Text.Length != 4)
	397	return;
	398	ushort physicalAddress = 0;
	399	if (!ushort.TryParse(tbPhysicalAddress.Text, NumberStyles.AllowHexSpecifier, null, out physicalAddress))
	400	return;
	401	SetControlsEnabled(false);
	402	SetControlText(cbPortNumber, string.Empty);
	403	SetControlText(cbConnectedDevice, string.Empty);
	404	ActiveProcess = new UpdatePhysicalAddress(ref Lib, physicalAddress);
	405	ActiveProcess.EventHandler += new EventHandler<UpdateEvent>(ProcessEventHandler);
	406	(new Thread(new ThreadStart(ActiveProcess.Run))).Start();
	407	}
	408	}
	409	}
	410
	411	internal class CecCallbackWrapper : CecCallbackMethods
	412	{
	413	public CecCallbackWrapper(CecConfigGUI gui)
	414	{
	415	Gui = gui;
	416	}
	417
	418	public override int ReceiveCommand(CecCommand command)
	419	{
	420	return Gui.ReceiveCommand(command);
	421	}
	422
	423	public override int ReceiveKeypress(CecKeypress key)
	424	{
	425	return Gui.ReceiveKeypress(key);
	426	}
	427
	428	public override int ReceiveLogMessage(CecLogMessage message)
	429	{
	430	return Gui.ReceiveLogMessage(message);
	431	}
	432
	433	private CecConfigGUI Gui;
	434	}
	435	}