File CameraSelectionControl.xaml.cs

File List > CameraSelection > CameraSelectionControl.xaml.cs

Go to the documentation of this file

//=============================================================================
// Copyright (c) 2026 FLIR Integrated Imaging Solutions, Inc. All Rights Reserved.
//
// This software is the confidential and proprietary information of FLIR
// Integrated Imaging Solutions, Inc. ("Confidential Information"). You
// shall not disclose such Confidential Information and shall use it only in
// accordance with the terms of the license agreement you entered into
// with FLIR Integrated Imaging Solutions, Inc. (FLIR).
//
// FLIR MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
// SOFTWARE, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE, OR NON-INFRINGEMENT. FLIR SHALL NOT BE LIABLE FOR ANY DAMAGES
// SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
// THIS SOFTWARE OR ITS DERIVATIVES.
//=============================================================================

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using SpinnakerNET;
using SpinnakerNET.GenApi;

namespace SpinnakerNET.GUI
{
    namespace WPFControls
    {


        public partial class CameraSelectionControl : UserControl, IDisposable, ISettings
        {
            private CameraSelectionInternal _camSelCtrl;
            private bool m_isDisposed = false;
            PersistentSettings _settings;
            bool _applyingSettings = false;
            bool _initializing = false;

            public bool DisplayAllAdapters
            {
                get
                {
                    return _camSelCtrl.DisplayAllAdapters;
                }
                set
                {
                    _camSelCtrl.DisplayAllAdapters = value;

                    // Save settings
                    SaveSettings();
                }
            }

            public bool MultiDeviceSelection
            {
                get
                {
                    return _camSelCtrl.MultiDeviceSelect;
                }
                set
                {
                    _camSelCtrl.MultiDeviceSelect = value;

                    // Save settings
                    SaveSettings();
                }
            }

            public void Dispose()
            {
                Dispose(true);
                GC.SuppressFinalize(this);
            }

            protected virtual void Dispose(bool disposing)
            {
                if (m_isDisposed)
                    return;

                if (disposing)
                {
                    _camSelCtrl.Dispose();
                }

                m_isDisposed = true;
            }

#region PUBLIC EVENTS

            public event CameraSelectionWindow.DeviceDoubleClickedEventHandler OnDeviceDoubleClicked;

            public event CameraSelectionWindow.DeviceClickedEventHandler OnDeviceClicked;
#endregion

            public CameraSelectionControl()
            {
                _initializing = true;

                InitializeComponent();

                _camSelCtrl = new CameraSelectionInternal();

                _camSelCtrl.OnDeviceDoubleClicked +=
                    new CameraSelectionWindow.DeviceDoubleClickedEventHandler(DeviceDoubleClicked);

                _camSelCtrl.OnDeviceClicked += new CameraSelectionWindow.DeviceClickedEventHandler(DeviceClicked);

                _camSelCtrl.OnSettingsChanged += CamSelCtrl_OnSettingsChanged;

                dock.Children.Add(_camSelCtrl);

                _settings = PersistentSettings.Instance;

                _initializing = false;
            }

            public void RegisterStartStopContextMenuEvent(CameraSelectionWindow.DeviceStartStopEventHandler handler)
            {
                _camSelCtrl.RegisterStartStopContextMenuEvent(handler);
            }

            public void RegisterConfigureDeviceContextMenuEvent(
                CameraSelectionWindow.DeviceSelectedToConfigHandler handler)
            {
                _camSelCtrl.RegisterConfigureDeviceContextMenuEvent(handler);
            }

            public void RegisterDisconnectDeviceMenuEvent(CameraSelectionWindow.DeviceDisconnectEventHandler handler)
            {
                _camSelCtrl.RegisterOnDeviceDisconnectCommandExecutedEvent(handler);
            }

            public void UnregisterStartStopContextMenuEvent(CameraSelectionWindow.DeviceStartStopEventHandler handler)
            {
                _camSelCtrl.UnregisterStartStopContextMenuEvent(handler);
            }

            public void UnregisterConfigureDeviceContextMenuEvent(
                CameraSelectionWindow.DeviceSelectedToConfigHandler handler)
            {
                _camSelCtrl.UnregisterConfigureDeviceContextMenuEvent(handler);
            }

            public void UnregisterDisconnectDeviceMenuEvent(CameraSelectionWindow.DeviceDisconnectEventHandler handler)
            {
                _camSelCtrl.UnregisterOnDeviceDisconnectCommandExecutedEvent(handler);
            }

            public void RegisterFirmwareUpdateStartingEvent(
                CameraSelectionWindow.DeviceFirmwareUpdateEventHandler handler)
            {
                _camSelCtrl.RegisterFirmwareUpdateStartingEvent(handler);
            }

            public void RegisterFirmwareUpdateFinishedEvent(
                CameraSelectionWindow.DeviceFirmwareUpdateEventHandler handler)
            {
                _camSelCtrl.RegisterFirmwareUpdateFinishedEvent(handler);
            }

            public void UnregisterFirmwareUpdateStartingEvent(
                CameraSelectionWindow.DeviceFirmwareUpdateEventHandler handler)
            {
                _camSelCtrl.UnregisterFirmwareUpdateStartingEvent(handler);
            }

            public void UnregisterFirmwareUpdateFinishedEvent(
                CameraSelectionWindow.DeviceFirmwareUpdateEventHandler handler)
            {
                _camSelCtrl.UnregisterFirmwareUpdateFinishedEvent(handler);
            }

            public void RegisterDriverSwitchStartingEvent(CameraSelectionWindow.DeviceDriverSwitchEventHandler handler)
            {
                _camSelCtrl.RegisterDriverSwitchStartingEvent(handler);
            }

            public void RegisterDriverSwitchFinishedEvent(CameraSelectionWindow.DeviceDriverSwitchEventHandler handler)
            {
                _camSelCtrl.RegisterDriverSwitchFinishedEvent(handler);
            }

            public void UnregisterDriverSwitchStartingEvent(
                CameraSelectionWindow.DeviceDriverSwitchEventHandler handler)
            {
                _camSelCtrl.UnregisterDriverSwitchStartingEvent(handler);
            }

            public void UnregisterDriverSwitchFinishedEvent(
                CameraSelectionWindow.DeviceDriverSwitchEventHandler handler)
            {
                _camSelCtrl.UnregisterDriverSwitchFinishedEvent(handler);
            }

            public void RegisterIPConfigStartingEvent(CameraSelectionWindow.DeviceIPConfigEventHandler handler)
            {
                _camSelCtrl.RegisterIPConfigStartingEvent(handler);
            }

            public void RegisterIPConfigFinishedEvent(CameraSelectionWindow.DeviceIPConfigEventHandler handler)
            {
                _camSelCtrl.RegisterIPConfigFinishedEvent(handler);
            }

            public void UnregisterIPConfigStartingEvent(CameraSelectionWindow.DeviceIPConfigEventHandler handler)
            {
                _camSelCtrl.UnregisterIPConfigStartingEvent(handler);
            }

            public void UnregisterIPConfigFinishedEvent(CameraSelectionWindow.DeviceIPConfigEventHandler handler)
            {
                _camSelCtrl.UnregisterIPConfigFinishedEvent(handler);
            }

            void DeviceClicked(object sender, CameraSelectionWindow.DeviceEventArgs args)
            {
                if (OnDeviceClicked != null)
                {
                    SpinnakerNET.GUI.CameraSelectionWindow.DeviceEventArgs publicArgs =
                        new SpinnakerNET.GUI.CameraSelectionWindow.DeviceEventArgs();
                    publicArgs.Camera = args.Camera;
                    publicArgs.Interface = args.Interface;
                    publicArgs.System = args.System;
                    publicArgs.IsCamera = args.IsCamera;
                    publicArgs.IsSystem = args.IsSystem;
                    OnDeviceClicked(this, publicArgs);
                }
            }

            void DeviceDoubleClicked(object sender, CameraSelectionWindow.DeviceEventArgs args)
            {
                if (OnDeviceDoubleClicked != null)
                {
                    SpinnakerNET.GUI.CameraSelectionWindow.DeviceEventArgs publicArgs =
                        new SpinnakerNET.GUI.CameraSelectionWindow.DeviceEventArgs();
                    publicArgs.Camera = args.Camera;
                    publicArgs.Interface = args.Interface;
                    publicArgs.System = args.System;
                    publicArgs.IsCamera = args.IsCamera;
                    publicArgs.IsSystem = args.IsSystem;
                    OnDeviceDoubleClicked(this, publicArgs);
                }
            }

            public void Refresh()
            {
                if (_camSelCtrl != null)
                {
                    _camSelCtrl.RefreshCameraList();
                }
            }

            public void HideToolbar()
            {
                _camSelCtrl.SetToolBarVisibility(false);
            }

            public void ShowToolbar()
            {
                _camSelCtrl.SetToolBarVisibility(true);
            }

            public static long GetInterfaceLinkSpeedFromCamera(StringNode camSerialNum)
            {
                return CameraSelectionInternal.GetInterfaceLinkSpeedFromCamera(camSerialNum);
            }

            public bool IsFirmwareUpdateInProgress()
            {
                return _camSelCtrl.IsFirmwareUpdateInProgress;
            }

            internal string GetDebugTimingInformation()
            {
                return _camSelCtrl.GetDebugTimingInformation();
            }

            public void ApplySettings(PersistentSettings settings)
            {
                try
                {
                    _applyingSettings = true;

                    DisplayAllAdapters = settings.CameraSelectionControlPersistentSettings.ShowAllAdapters;
                }
                catch (Exception ex)
                {
                    System.Windows.Forms.MessageBox.Show(
                        ex.Message,
                        "Problem Applying Settings",
                        System.Windows.Forms.MessageBoxButtons.OK,
                        System.Windows.Forms.MessageBoxIcon.Exclamation);
                }
                finally
                {
                    _applyingSettings = false;
                }
            }

            public void FetchSettings(PersistentSettings settings)
            {
                try
                {
                    settings.CameraSelectionControlPersistentSettings.ShowAllAdapters = DisplayAllAdapters;
                }
                catch (Exception ex)
                {
                    System.Windows.Forms.MessageBox.Show(
                        ex.Message,
                        "Problem Fetching Settings",
                        System.Windows.Forms.MessageBoxButtons.OK,
                        System.Windows.Forms.MessageBoxIcon.Exclamation);
                }
            }

            public void SaveSettings()
            {
                if (_initializing || _applyingSettings)
                {
                    return;
                }

                // Load persisted settings
                _settings.LoadPersistentSettings();

                // Update settings with latest config
                FetchSettings(_settings);

                // Persist to file
                _settings.SavePersistentSettings();
            }

            void CamSelCtrl_OnSettingsChanged()
            {
                SaveSettings();
            }
        }

    }
}