CEC_HDMI_PORT variable support for exynos hardware.
[deb_libcec.git] / CECController.cs
... / ...
CommitLineData
1/*
2 * This file is part of the libCEC(R) library.
3 *
4 * libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited. All rights reserved.
5 * libCEC(R) is an original work, containing original code.
6 *
7 * libCEC(R) is a trademark of Pulse-Eight Limited.
8 *
9 * This program is dual-licensed; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 *
23 *
24 * Alternatively, you can license this library under a commercial license,
25 * please contact Pulse-Eight Licensing for more information.
26 *
27 * For more information contact:
28 * Pulse-Eight Licensing <license@pulse-eight.com>
29 * http://www.pulse-eight.com/
30 * http://www.pulse-eight.net/
31 */
32
33using System;
34using System.Collections.Generic;
35using System.Windows.Forms;
36using CecSharp;
37using LibCECTray.Properties;
38using LibCECTray.controller.applications;
39using LibCECTray.settings;
40using LibCECTray.ui;
41
42namespace LibCECTray.controller
43{
44 internal class CECController : CecCallbackMethods
45 {
46 public CECController(CECTray gui)
47 {
48 _gui = gui;
49 CECActions = new Actions(this);
50
51 InitialiseGui();
52
53 Settings.SettingChanged += OnSettingChanged;
54 }
55
56 #region Settings
57 /// <summary>
58 /// Called when a setting changed
59 /// </summary>
60 /// <param name="setting">The setting that changed</param>
61 /// <param name="oldValue">The old value</param>
62 /// <param name="newValue">The new value</param>
63 private void OnSettingChanged(CECSetting setting, object oldValue, object newValue)
64 {
65 if (setting.KeyName == CECSettings.KeyHDMIPort)
66 {
67 CECSettingByte byteSetting = setting as CECSettingByte;
68 if (byteSetting != null)
69 {
70 if (!Settings.OverridePhysicalAddress.Value)
71 Config.HDMIPort = byteSetting.Value;
72 CECActions.SetConnectedDevice(Settings.ConnectedDevice.Value, byteSetting.Value);
73 }
74 }
75 else if (setting.KeyName == CECSettings.KeyConnectedToHDMIDevice)
76 {
77 CECSettingLogicalAddress laSetting = setting as CECSettingLogicalAddress;
78 if (laSetting != null)
79 {
80 if (!Settings.OverridePhysicalAddress.Value)
81 Config.BaseDevice = laSetting.Value;
82 CECActions.SetConnectedDevice(laSetting.Value, Settings.HDMIPort.Value);
83 }
84 }
85 else if (setting.KeyName == CECSettings.KeyPhysicalAddress)
86 {
87 CECSettingUShort ushortSetting = setting as CECSettingUShort;
88 if (ushortSetting != null && Settings.OverridePhysicalAddress.Value && Config.PhysicalAddress != ushortSetting.Value)
89 {
90 Config.PhysicalAddress = ushortSetting.Value;
91 CECActions.SetPhysicalAddress(ushortSetting.Value);
92 }
93 }
94 else if (setting.KeyName == CECSettings.KeyOverridePhysicalAddress)
95 {
96 CECSettingBool boolSetting = setting as CECSettingBool;
97 if (boolSetting != null)
98 {
99 Settings.PhysicalAddress.Enabled = boolSetting.Value;
100 Settings.HDMIPort.Enabled = !boolSetting.Value;
101 Settings.ConnectedDevice.Enabled = !boolSetting.Value;
102 if (boolSetting.Value)
103 {
104 Config.BaseDevice = Settings.ConnectedDevice.Value;
105 Config.HDMIPort = 0;
106 Config.PhysicalAddress = Settings.PhysicalAddress.Value;
107 }
108 else
109 {
110 Config.BaseDevice = Settings.ConnectedDevice.Value;
111 Config.HDMIPort = Settings.HDMIPort.Value;
112 Config.PhysicalAddress = 0xFFFF;
113 }
114 }
115 }
116 else if (setting.KeyName == CECSettings.KeyDeviceType)
117 {
118 CECSettingDeviceType dtSetting = setting as CECSettingDeviceType;
119 if (dtSetting != null)
120 {
121 if (dtSetting.Value != Config.DeviceTypes.Types[0] && Settings.OverrideTVVendor.Value)
122 {
123 Config.DeviceTypes.Types[0] = dtSetting.Value;
124 if (!_deviceChangeWarningDisplayed)
125 {
126 _deviceChangeWarningDisplayed = true;
127 MessageBox.Show(Resources.device_type_changed, Resources.app_name, MessageBoxButtons.OK,
128 MessageBoxIcon.Warning);
129 }
130 }
131 }
132 }
133 else if (setting.KeyName == CECSettings.KeyOverrideTVVendor)
134 {
135 CECSettingBool boolSetting = setting as CECSettingBool;
136 if (boolSetting != null)
137 {
138 Settings.TVVendor.Enabled = boolSetting.Value;
139 Settings.TVVendor.Value = boolSetting.Value ? Lib.GetDeviceVendorId(CecLogicalAddress.Tv) : CecVendorId.Unknown;
140 Config.TvVendor = boolSetting.Value ? Settings.TVVendor.Value : CecVendorId.Unknown;
141 }
142 }
143 else if (setting.KeyName == CECSettings.KeyActivateSource)
144 {
145 CECSettingBool boolSetting = setting as CECSettingBool;
146 if (boolSetting != null)
147 Config.ActivateSource = boolSetting.Value;
148 }
149 else if (setting.KeyName == CECSettings.KeyTVVendor)
150 {
151 CECSettingVendorId vendorSetting = setting as CECSettingVendorId;
152 if (vendorSetting != null && Settings.OverrideTVVendor.Value)
153 Config.TvVendor = vendorSetting.Value;
154 }
155 else if (setting.KeyName == CECSettings.KeyWakeDevices)
156 {
157 CECSettingLogicalAddresses laSetting = setting as CECSettingLogicalAddresses;
158 if (laSetting != null)
159 Config.WakeDevices = laSetting.Value;
160 }
161 else if (setting.KeyName == CECSettings.KeyPowerOffDevices)
162 {
163 CECSettingLogicalAddresses laSetting = setting as CECSettingLogicalAddresses;
164 if (laSetting != null)
165 Config.PowerOffDevices = laSetting.Value;
166 }
167 }
168
169 /// <summary>
170 /// Persist all known settings in the registry
171 /// </summary>
172 public void PersistSettings()
173 {
174 /* save settings in the eeprom */
175 Lib.SetConfiguration(Config);
176 Lib.PersistConfiguration(Config);
177
178 /* and in the registry */
179 Settings.Persist();
180 }
181
182 /// <summary>
183 /// Reset all settings to their default values
184 /// </summary>
185 public void ResetDefaultSettings()
186 {
187 SetControlsEnabled(false);
188 _gui.ShowHideAdvanced(false);
189
190 CECActions.SuppressUpdates = true;
191 Settings.SetDefaultValues();
192 _config = null;
193 Lib.SetConfiguration(Config);
194 CECActions.SuppressUpdates = false;
195
196 _gui.ShowHideAdvanced(Settings.AdvancedMode.Value);
197 SetControlsEnabled(true);
198 }
199 #endregion
200
201 /// <summary>
202 /// Opens a connection to libCEC and register known applications
203 /// </summary>
204 public void Initialise()
205 {
206 CECActions.ConnectToDevice(Config);
207 Applications.Initialise(this);
208 }
209
210 /// <summary>
211 /// Closes the connection to libCEC
212 /// </summary>
213 public void Close()
214 {
215 Lib.DisableCallbacks();
216 Lib.StandbyDevices(CecLogicalAddress.Broadcast);
217 Lib.Close();
218 }
219
220 /// <summary>
221 /// Register a new application controller, which will add a new tab for the application
222 /// </summary>
223 /// <param name="app">The new application to register</param>
224 /// <returns>True when registered, false otherwise</returns>
225 public bool RegisterApplication(ApplicationController app)
226 {
227 if (_applications.Contains(app)) return false;
228 _applications.Add(app);
229
230 _gui.SuspendLayout();
231 _gui.TabControls.Add(app.UiControl);
232 _gui.ResumeLayout();
233
234 app.Initialise();
235
236 return true;
237 }
238
239 #region GUI controls
240 /// <summary>
241 /// Initialises the UI
242 /// </summary>
243 private void InitialiseGui()
244 {
245 _gui.SuspendLayout();
246 _gui.InitialiseSettingsComponent(Settings);
247
248 // add the controller tabs to the gui
249 foreach (var ui in ApplicationUIs)
250 _gui.TabControls.Add(ui);
251
252 // enable/disable advanced mode
253 _gui.ShowHideAdvanced(Settings.AdvancedMode.Value);
254
255 _gui.ResumeLayout();
256 }
257
258 /// <summary>
259 /// Display a dialog
260 /// </summary>
261 /// <param name="control">The dialog to display</param>
262 /// <param name="modal">True when modal</param>
263 public void DisplayDialog(Form control, bool modal)
264 {
265 _gui.DisplayDialog(control, modal);
266 }
267
268 /// <summary>
269 /// Changes the status text of this window
270 /// </summary>
271 /// <param name="status">The new status text</param>
272 public void SetStatusText(string status)
273 {
274 _gui.SetStatusText(status);
275 }
276
277 /// <summary>
278 /// Changes the progress bar value
279 /// </summary>
280 /// <param name="progress">The new progress percentage</param>
281 /// <param name="visible">True to make the bar visible, false otherwise</param>
282 public void SetProgressBar(int progress, bool visible)
283 {
284 _gui.SetProgressBar(progress, visible);
285 }
286
287 /// <summary>
288 /// Enable/disable all controls
289 /// </summary>
290 /// <param name="val">True to enable, false to disable</param>
291 public void SetControlsEnabled(bool val)
292 {
293 Settings.Enabled = val;
294 foreach (var app in _applications)
295 app.UiControl.SetEnabled(val);
296 _gui.SetControlsEnabled(val);
297 }
298
299 /// <summary>
300 /// (re)check the logical addresses of the active devices on the bus
301 /// </summary>
302 public void CheckActiveDevices()
303 {
304 var activeDevices = Lib.GetActiveDevices();
305 List<string> deviceList = new List<string>();
306 foreach (var activeDevice in activeDevices.Addresses)
307 {
308 if (activeDevice != CecLogicalAddress.Unknown)
309 deviceList.Add(string.Format("{0,1:X} : {1}", (int)activeDevice, Lib.ToString(activeDevice)));
310 }
311 deviceList.Add(string.Format("{0,1:X} : {1}", (int)CecLogicalAddress.Broadcast, Lib.ToString(CecLogicalAddress.Broadcast)));
312
313 _gui.SetActiveDevices(deviceList.ToArray());
314 }
315
316 /// <summary>
317 /// Show/hide the taskbar entry
318 /// </summary>
319 /// <param name="val">True to show, false to hide</param>
320 public void SetShowInTaskbar(bool val)
321 {
322 _gui.SetShowInTaskbar(val);
323 }
324
325 /// <summary>
326 /// Show or hide this window
327 /// </summary>
328 /// <param name="val">True to show, false to hide</param>
329 public void Hide(bool val)
330 {
331 _gui.SafeHide(val);
332 }
333 #endregion
334
335 #region Callbacks called by libCEC
336 public override int ReceiveCommand(CecCommand command)
337 {
338 return 0;
339 }
340
341 public override int ReceiveKeypress(CecKeypress key)
342 {
343 foreach (var app in _applications)
344 {
345 bool keySent = app.SendKey(key, app.UiName == _gui.SelectedTabName);
346
347 if (keySent)
348 {
349 string strLog = string.Format("sent key '{0}' to '{1}'", (int) key.Keycode, app.UiName) + Environment.NewLine;
350 _gui.AddLogMessage(strLog);
351 break;
352 }
353 }
354
355 return 1;
356 }
357
358 public override int ReceiveLogMessage(CecLogMessage message)
359 {
360 _gui.AddLogMessage(message);
361 return 1;
362 }
363
364 public override int ConfigurationChanged(LibCECConfiguration config)
365 {
366 Settings.PhysicalAddress.Value = Config.PhysicalAddress;
367 Settings.ConnectedDevice.Value = Config.BaseDevice == CecLogicalAddress.AudioSystem ? CecLogicalAddress.AudioSystem : CecLogicalAddress.Tv;
368 Settings.HDMIPort.Value = Config.HDMIPort;
369 Settings.WakeDevices.Value = Config.WakeDevices;
370 Settings.PowerOffDevices.Value = Config.PowerOffDevices;
371 Settings.ActivateSource.Value = Config.ActivateSource;
372 Settings.DeviceType.Value = config.DeviceTypes.Types[0];
373
374 if (config.TvVendor != CecVendorId.Unknown)
375 {
376 Settings.OverrideTVVendor.Value = true;
377 Settings.TVVendor.Value = config.TvVendor;
378 }
379 else
380 {
381 Settings.OverrideTVVendor.Value = false;
382 }
383
384 _gui.SetControlText(_gui, Resources.app_name + " - libCEC " + Lib.ToString(Config.ServerVersion));
385
386 CECActions.UpdatePhysicalAddress();
387 return 1;
388 }
389
390 public override void SourceActivated(CecLogicalAddress logicalAddress, bool activated)
391 {
392 if (!activated)
393 return;
394
395 foreach (var app in _applications)
396 {
397 if (app.AutoStartApplication.Value)
398 app.Start(false);
399 }
400 }
401 #endregion
402
403 #region Members
404 /// <summary>
405 /// List of tab pages for each application that the UI supports
406 /// </summary>
407 public List<ControllerTabPage> ApplicationUIs
408 {
409 get
410 {
411 List<ControllerTabPage> retVal = new List<ControllerTabPage>();
412 foreach (var app in _applications)
413 retVal.Add(app.UiControl);
414 return retVal;
415 }
416 }
417
418 /// <summary>
419 /// List of application controllers that the UI supports
420 /// </summary>
421 private readonly List<ApplicationController> _applications = new List<ApplicationController>();
422
423 /// <summary>
424 /// Settings that are persisted in the registry (when not using the default value)
425 /// </summary>
426 public CECSettings Settings
427 {
428 get { return _settings ?? (_settings = new CECSettings(OnSettingChanged)); }
429 }
430 private CECSettings _settings;
431
432 /// <summary>
433 /// libCEC configuration for the application
434 /// </summary>
435 private LibCECConfiguration Config
436 {
437 get
438 {
439 if (_config == null)
440 {
441 _config = new LibCECConfiguration { DeviceName = "CEC Tray", ClientVersion = CecClientVersion.Version2_0_5 };
442 _config.DeviceTypes.Types[0] = CecDeviceType.RecordingDevice;
443 _config.SetCallbacks(this);
444
445 if (Settings.OverridePhysicalAddress.Value)
446 {
447 _config.PhysicalAddress = Settings.PhysicalAddress.Value;
448 _config.HDMIPort = 0;
449 _config.BaseDevice = CecLogicalAddress.Unknown;
450 }
451 else
452 {
453 _config.PhysicalAddress = 0;
454 _config.HDMIPort = Settings.HDMIPort.Value;
455 _config.BaseDevice = Settings.ConnectedDevice.Value;
456 }
457 _config.ActivateSource = Settings.ActivateSource.Value;
458 _config.DeviceTypes.Types[0] = Settings.DeviceType.Value;
459 if (Settings.OverrideTVVendor.Value)
460 _config.TvVendor = Settings.TVVendor.Value;
461 _config.WakeDevices = Settings.WakeDevices.Value;
462 _config.PowerOffDevices = Settings.PowerOffDevices.Value;
463 }
464 return _config;
465 }
466 }
467 private LibCECConfiguration _config;
468
469 /// <summary>
470 /// Get build info from libCEC
471 /// </summary>
472 public string LibInfo
473 {
474 get { return Lib.GetLibInfo(); }
475 }
476
477 /// <summary>
478 /// libCEC API version
479 /// </summary>
480 public string LibServerVersion
481 {
482 get { return Lib.ToString(Config.ServerVersion); }
483 }
484
485 /// <summary>
486 /// libCEC client API version
487 /// </summary>
488 public string LibClientVersion
489 {
490 get { return Lib.ToString(Config.ClientVersion); }
491 }
492
493 /// <summary>
494 /// Get the usb vendor id
495 /// </summary>
496 public ushort AdapterVendorId
497 {
498 get { return Lib.GetAdapterVendorId(); }
499 }
500
501 /// <summary>
502 /// Get the usb product id
503 /// </summary>
504 public ushort AdapterProductId
505 {
506 get { return Lib.GetAdapterProductId(); }
507 }
508
509
510 /// <summary>
511 /// libCEC
512 /// </summary>
513 public LibCecSharp Lib
514 {
515 get { return _lib ?? (_lib = new LibCecSharp(Config)); }
516 }
517 private LibCecSharp _lib;
518
519 private readonly CECTray _gui;
520 public Actions CECActions;
521 private bool _deviceChangeWarningDisplayed;
522
523 #endregion
524 }
525}