Sicherung

FSI.Lib/FSI.Lib/Audio/AudioManager.cs

@@ -0,0 +1,608 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace FSI.Lib.Audio
+{
+    /// <summary>
+    /// Controls audio using the Windows CoreAudio API
+    /// from: http://stackoverflow.com/questions/14306048/controling-volume-mixer
+    /// and: http://netcoreaudio.codeplex.com/
+    /// </summary>
+    public static class AudioManager
+    {
+        #region Master Volume Manipulation
+
+        /// <summary>
+        /// Gets the current master volume in scalar values (percentage)
+        /// </summary>
+        /// <returns>-1 in case of an error, if successful the value will be between 0 and 100</returns>
+        public static float GetMasterVolume()
+        {
+            IAudioEndpointVolume masterVol = null;
+            try
+            {
+                masterVol = GetMasterVolumeObject();
+                if (masterVol == null)
+                    return -1;
+
+                masterVol.GetMasterVolumeLevelScalar(out float volumeLevel);
+                return volumeLevel * 100;
+            }
+            finally
+            {
+                if (masterVol != null)
+                    Marshal.ReleaseComObject(masterVol);
+            }
+        }
+
+        /// <summary>
+        /// Gets the mute state of the master volume. 
+        /// While the volume can be muted the <see cref="GetMasterVolume"/> will still return the pre-muted volume value.
+        /// </summary>
+        /// <returns>false if not muted, true if volume is muted</returns>
+        public static bool GetMasterVolumeMute()
+        {
+            IAudioEndpointVolume masterVol = null;
+            try
+            {
+                masterVol = GetMasterVolumeObject();
+                if (masterVol == null)
+                    return false;
+
+                masterVol.GetMute(out bool isMuted);
+                return isMuted;
+            }
+            finally
+            {
+                if (masterVol != null)
+                    Marshal.ReleaseComObject(masterVol);
+            }
+        }
+
+        /// <summary>
+        /// Sets the master volume to a specific level
+        /// </summary>
+        /// <param name="newLevel">Value between 0 and 100 indicating the desired scalar value of the volume</param>
+        public static void SetMasterVolume(float newLevel)
+        {
+            IAudioEndpointVolume masterVol = null;
+            try
+            {
+                masterVol = GetMasterVolumeObject();
+                if (masterVol == null)
+                    return;
+
+                masterVol.SetMasterVolumeLevelScalar(newLevel / 100, Guid.Empty);
+            }
+            finally
+            {
+                if (masterVol != null)
+                    Marshal.ReleaseComObject(masterVol);
+            }
+        }
+
+        /// <summary>
+        /// Increments or decrements the current volume level by the <see cref="stepAmount"/>.
+        /// </summary>
+        /// <param name="stepAmount">Value between -100 and 100 indicating the desired step amount. Use negative numbers to decrease
+        /// the volume and positive numbers to increase it.</param>
+        /// <returns>the new volume level assigned</returns>
+        public static float StepMasterVolume(float stepAmount)
+        {
+            IAudioEndpointVolume masterVol = null;
+            try
+            {
+                masterVol = GetMasterVolumeObject();
+                if (masterVol == null)
+                    return -1;
+
+                float stepAmountScaled = stepAmount / 100;
+
+                // Get the level
+                masterVol.GetMasterVolumeLevelScalar(out float volumeLevel);
+
+                // Calculate the new level
+                float newLevel = volumeLevel + stepAmountScaled;
+                newLevel = Math.Min(1, newLevel);
+                newLevel = Math.Max(0, newLevel);
+
+                masterVol.SetMasterVolumeLevelScalar(newLevel, Guid.Empty);
+
+                // Return the new volume level that was set
+                return newLevel * 100;
+            }
+            finally
+            {
+                if (masterVol != null)
+                    Marshal.ReleaseComObject(masterVol);
+            }
+        }
+
+        /// <summary>
+        /// Mute or unmute the master volume
+        /// </summary>
+        /// <param name="isMuted">true to mute the master volume, false to unmute</param>
+        public static void SetMasterVolumeMute(bool isMuted)
+        {
+            IAudioEndpointVolume masterVol = null;
+            try
+            {
+                masterVol = GetMasterVolumeObject();
+                if (masterVol == null)
+                    return;
+
+                masterVol.SetMute(isMuted, Guid.Empty);
+            }
+            finally
+            {
+                if (masterVol != null)
+                    Marshal.ReleaseComObject(masterVol);
+            }
+        }
+
+        /// <summary>
+        /// Switches between the master volume mute states depending on the current state
+        /// </summary>
+        /// <returns>the current mute state, true if the volume was muted, false if unmuted</returns>
+        public static bool ToggleMasterVolumeMute()
+        {
+            IAudioEndpointVolume masterVol = null;
+            try
+            {
+                masterVol = GetMasterVolumeObject();
+                if (masterVol == null)
+                    return false;
+
+                masterVol.GetMute(out bool isMuted);
+                masterVol.SetMute(!isMuted, Guid.Empty);
+
+                return !isMuted;
+            }
+            finally
+            {
+                if (masterVol != null)
+                    Marshal.ReleaseComObject(masterVol);
+            }
+        }
+
+        private static IAudioEndpointVolume GetMasterVolumeObject()
+        {
+            IMMDeviceEnumerator deviceEnumerator = null;
+            IMMDevice speakers = null;
+            try
+            {
+                deviceEnumerator = (IMMDeviceEnumerator)(new MMDeviceEnumerator());
+                deviceEnumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia, out speakers);
+
+                Guid IID_IAudioEndpointVolume = typeof(IAudioEndpointVolume).GUID;
+                speakers.Activate(ref IID_IAudioEndpointVolume, 0, IntPtr.Zero, out object o);
+                IAudioEndpointVolume masterVol = (IAudioEndpointVolume)o;
+
+                return masterVol;
+            }
+            finally
+            {
+                if (speakers != null) Marshal.ReleaseComObject(speakers);
+                if (deviceEnumerator != null) Marshal.ReleaseComObject(deviceEnumerator);
+            }
+        }
+
+        #endregion
+
+        #region Individual Application Volume Manipulation
+
+        public static float? GetApplicationVolume(int pid)
+        {
+            ISimpleAudioVolume volume = GetVolumeObject(pid);
+            if (volume == null)
+                return null;
+
+            volume.GetMasterVolume(out float level);
+            Marshal.ReleaseComObject(volume);
+            return level * 100;
+        }
+
+        public static bool? GetApplicationMute(int pid)
+        {
+            ISimpleAudioVolume volume = GetVolumeObject(pid);
+            if (volume == null)
+                return null;
+
+            volume.GetMute(out bool mute);
+            Marshal.ReleaseComObject(volume);
+            return mute;
+        }
+
+        public static void SetApplicationVolume(int pid, float level)
+        {
+            ISimpleAudioVolume volume = GetVolumeObject(pid);
+            if (volume == null)
+                return;
+
+            Guid guid = Guid.Empty;
+            volume.SetMasterVolume(level / 100, ref guid);
+            Marshal.ReleaseComObject(volume);
+        }
+
+        public static void SetApplicationMute(int pid, bool mute)
+        {
+            ISimpleAudioVolume volume = GetVolumeObject(pid);
+            if (volume == null)
+                return;
+
+            Guid guid = Guid.Empty;
+            volume.SetMute(mute, ref guid);
+            Marshal.ReleaseComObject(volume);
+        }
+
+        private static ISimpleAudioVolume GetVolumeObject(int pid)
+        {
+            IMMDeviceEnumerator deviceEnumerator = null;
+            IAudioSessionEnumerator sessionEnumerator = null;
+            IAudioSessionManager2 mgr = null;
+            IMMDevice speakers = null;
+            try
+            {
+                // get the speakers (1st render + multimedia) device
+                deviceEnumerator = (IMMDeviceEnumerator)(new MMDeviceEnumerator());
+                deviceEnumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia, out speakers);
+
+                // activate the session manager. we need the enumerator
+                Guid IID_IAudioSessionManager2 = typeof(IAudioSessionManager2).GUID;
+                speakers.Activate(ref IID_IAudioSessionManager2, 0, IntPtr.Zero, out object o);
+                mgr = (IAudioSessionManager2)o;
+
+                // enumerate sessions for on this device
+                mgr.GetSessionEnumerator(out sessionEnumerator);
+                sessionEnumerator.GetCount(out int count);
+
+                // search for an audio session with the required process-id
+                ISimpleAudioVolume volumeControl = null;
+                for (int i = 0; i < count; ++i)
+                {
+                    IAudioSessionControl2 ctl = null;
+                    try
+                    {
+                        sessionEnumerator.GetSession(i, out ctl);
+
+                        // NOTE: we could also use the app name from ctl.GetDisplayName()
+                        ctl.GetProcessId(out int cpid);
+
+                        if (cpid == pid)
+                        {
+                            volumeControl = ctl as ISimpleAudioVolume;
+                            break;
+                        }
+                    }
+                    finally
+                    {
+                        if (ctl != null) Marshal.ReleaseComObject(ctl);
+                    }
+                }
+
+                return volumeControl;
+            }
+            finally
+            {
+                if (sessionEnumerator != null) Marshal.ReleaseComObject(sessionEnumerator);
+                if (mgr != null) Marshal.ReleaseComObject(mgr);
+                if (speakers != null) Marshal.ReleaseComObject(speakers);
+                if (deviceEnumerator != null) Marshal.ReleaseComObject(deviceEnumerator);
+            }
+        }
+
+        #endregion
+
+    }
+
+    #region Abstracted COM interfaces from Windows CoreAudio API
+
+    [ComImport]
+    [Guid("BCDE0395-E52F-467C-8E3D-C4579291692E")]
+    internal class MMDeviceEnumerator
+    {
+    }
+
+    internal enum EDataFlow
+    {
+        eRender,
+        eCapture,
+        eAll,
+        EDataFlow_enum_count
+    }
+
+    internal enum ERole
+    {
+        eConsole,
+        eMultimedia,
+        eCommunications,
+        ERole_enum_count
+    }
+
+    [Guid("A95664D2-9614-4F35-A746-DE8DB63617E6"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    internal interface IMMDeviceEnumerator
+    {
+        int NotImpl1();
+
+        [PreserveSig]
+        int GetDefaultAudioEndpoint(EDataFlow dataFlow, ERole role, out IMMDevice ppDevice);
+
+        // the rest is not implemented
+    }
+
+    [Guid("D666063F-1587-4E43-81F1-B948E807363F"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    internal interface IMMDevice
+    {
+        [PreserveSig]
+        int Activate(ref Guid iid, int dwClsCtx, IntPtr pActivationParams, [MarshalAs(UnmanagedType.IUnknown)] out object ppInterface);
+
+        // the rest is not implemented
+    }
+
+    [Guid("77AA99A0-1BD6-484F-8BC7-2C654C9A9B6F"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    internal interface IAudioSessionManager2
+    {
+        int NotImpl1();
+        int NotImpl2();
+
+        [PreserveSig]
+        int GetSessionEnumerator(out IAudioSessionEnumerator SessionEnum);
+
+        // the rest is not implemented
+    }
+
+    [Guid("E2F5BB11-0570-40CA-ACDD-3AA01277DEE8"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    internal interface IAudioSessionEnumerator
+    {
+        [PreserveSig]
+        int GetCount(out int SessionCount);
+
+        [PreserveSig]
+        int GetSession(int SessionCount, out IAudioSessionControl2 Session);
+    }
+
+    [Guid("87CE5498-68D6-44E5-9215-6DA47EF883D8"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    internal interface ISimpleAudioVolume
+    {
+        [PreserveSig]
+        int SetMasterVolume(float fLevel, ref Guid EventContext);
+
+        [PreserveSig]
+        int GetMasterVolume(out float pfLevel);
+
+        [PreserveSig]
+        int SetMute(bool bMute, ref Guid EventContext);
+
+        [PreserveSig]
+        int GetMute(out bool pbMute);
+    }
+
+    [Guid("bfb7ff88-7239-4fc9-8fa2-07c950be9c6d"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    internal interface IAudioSessionControl2
+    {
+        // IAudioSessionControl
+        [PreserveSig]
+        int NotImpl0();
+
+        [PreserveSig]
+        int GetDisplayName([MarshalAs(UnmanagedType.LPWStr)] out string pRetVal);
+
+        [PreserveSig]
+        int SetDisplayName([MarshalAs(UnmanagedType.LPWStr)] string Value, [MarshalAs(UnmanagedType.LPStruct)] Guid EventContext);
+
+        [PreserveSig]
+        int GetIconPath([MarshalAs(UnmanagedType.LPWStr)] out string pRetVal);
+
+        [PreserveSig]
+        int SetIconPath([MarshalAs(UnmanagedType.LPWStr)] string Value, [MarshalAs(UnmanagedType.LPStruct)] Guid EventContext);
+
+        [PreserveSig]
+        int GetGroupingParam(out Guid pRetVal);
+
+        [PreserveSig]
+        int SetGroupingParam([MarshalAs(UnmanagedType.LPStruct)] Guid Override, [MarshalAs(UnmanagedType.LPStruct)] Guid EventContext);
+
+        [PreserveSig]
+        int NotImpl1();
+
+        [PreserveSig]
+        int NotImpl2();
+
+        // IAudioSessionControl2
+        [PreserveSig]
+        int GetSessionIdentifier([MarshalAs(UnmanagedType.LPWStr)] out string pRetVal);
+
+        [PreserveSig]
+        int GetSessionInstanceIdentifier([MarshalAs(UnmanagedType.LPWStr)] out string pRetVal);
+
+        [PreserveSig]
+        int GetProcessId(out int pRetVal);
+
+        [PreserveSig]
+        int IsSystemSoundsSession();
+
+        [PreserveSig]
+        int SetDuckingPreference(bool optOut);
+    }
+
+    // http://netcoreaudio.codeplex.com/SourceControl/latest#trunk/Code/CoreAudio/Interfaces/IAudioEndpointVolume.cs
+    [Guid("5CDF2C82-841E-4546-9722-0CF74078229A"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    public interface IAudioEndpointVolume
+    {
+        [PreserveSig]
+        int NotImpl1();
+
+        [PreserveSig]
+        int NotImpl2();
+
+        /// <summary>
+        /// Gets a count of the channels in the audio stream.
+        /// </summary>
+        /// <param name="channelCount">The number of channels.</param>
+        /// <returns>An HRESULT code indicating whether the operation passed of failed.</returns>
+        [PreserveSig]
+        int GetChannelCount(
+            [Out][MarshalAs(UnmanagedType.U4)] out UInt32 channelCount);
+
+        /// <summary>
+        /// Sets the master volume level of the audio stream, in decibels.
+        /// </summary>
+        /// <param name="level">The new master volume level in decibels.</param>
+        /// <param name="eventContext">A user context value that is passed to the notification callback.</param>
+        /// <returns>An HRESULT code indicating whether the operation passed of failed.</returns>
+        [PreserveSig]
+        int SetMasterVolumeLevel(
+            [In][MarshalAs(UnmanagedType.R4)] float level,
+            [In][MarshalAs(UnmanagedType.LPStruct)] Guid eventContext);
+
+        /// <summary>
+        /// Sets the master volume level, expressed as a normalized, audio-tapered value.
+        /// </summary>
+        /// <param name="level">The new master volume level expressed as a normalized value between 0.0 and 1.0.</param>
+        /// <param name="eventContext">A user context value that is passed to the notification callback.</param>
+        /// <returns>An HRESULT code indicating whether the operation passed of failed.</returns>
+        [PreserveSig]
+        int SetMasterVolumeLevelScalar(
+            [In][MarshalAs(UnmanagedType.R4)] float level,
+            [In][MarshalAs(UnmanagedType.LPStruct)] Guid eventContext);
+
+        /// <summary>
+        /// Gets the master volume level of the audio stream, in decibels.
+        /// </summary>
+        /// <param name="level">The volume level in decibels.</param>
+        /// <returns>An HRESULT code indicating whether the operation passed of failed.</returns>
+        [PreserveSig]
+        int GetMasterVolumeLevel(
+            [Out][MarshalAs(UnmanagedType.R4)] out float level);
+
+        /// <summary>
+        /// Gets the master volume level, expressed as a normalized, audio-tapered value.
+        /// </summary>
+        /// <param name="level">The volume level expressed as a normalized value between 0.0 and 1.0.</param>
+        /// <returns>An HRESULT code indicating whether the operation passed of failed.</returns>
+        [PreserveSig]
+        int GetMasterVolumeLevelScalar(
+            [Out][MarshalAs(UnmanagedType.R4)] out float level);
+
+        /// <summary>
+        /// Sets the volume level, in decibels, of the specified channel of the audio stream.
+        /// </summary>
+        /// <param name="channelNumber">The channel number.</param>
+        /// <param name="level">The new volume level in decibels.</param>
+        /// <param name="eventContext">A user context value that is passed to the notification callback.</param>
+        /// <returns>An HRESULT code indicating whether the operation passed of failed.</returns>
+        [PreserveSig]
+        int SetChannelVolumeLevel(
+            [In][MarshalAs(UnmanagedType.U4)] UInt32 channelNumber,
+            [In][MarshalAs(UnmanagedType.R4)] float level,
+            [In][MarshalAs(UnmanagedType.LPStruct)] Guid eventContext);
+
+        /// <summary>
+        /// Sets the normalized, audio-tapered volume level of the specified channel in the audio stream.
+        /// </summary>
+        /// <param name="channelNumber">The channel number.</param>
+        /// <param name="level">The new master volume level expressed as a normalized value between 0.0 and 1.0.</param>
+        /// <param name="eventContext">A user context value that is passed to the notification callback.</param>
+        /// <returns>An HRESULT code indicating whether the operation passed of failed.</returns>
+        [PreserveSig]
+        int SetChannelVolumeLevelScalar(
+            [In][MarshalAs(UnmanagedType.U4)] UInt32 channelNumber,
+            [In][MarshalAs(UnmanagedType.R4)] float level,
+            [In][MarshalAs(UnmanagedType.LPStruct)] Guid eventContext);
+
+        /// <summary>
+        /// Gets the volume level, in decibels, of the specified channel in the audio stream.
+        /// </summary>
+        /// <param name="channelNumber">The zero-based channel number.</param>
+		/// <param name="level">The volume level in decibels.</param>
+        /// <returns>An HRESULT code indicating whether the operation passed of failed.</returns>
+        [PreserveSig]
+        int GetChannelVolumeLevel(
+            [In][MarshalAs(UnmanagedType.U4)] UInt32 channelNumber,
+            [Out][MarshalAs(UnmanagedType.R4)] out float level);
+
+        /// <summary>
+        /// Gets the normalized, audio-tapered volume level of the specified channel of the audio stream.
+        /// </summary>
+        /// <param name="channelNumber">The zero-based channel number.</param>
+		/// <param name="level">The volume level expressed as a normalized value between 0.0 and 1.0.</param>
+        /// <returns>An HRESULT code indicating whether the operation passed of failed.</returns>
+        [PreserveSig]
+        int GetChannelVolumeLevelScalar(
+            [In][MarshalAs(UnmanagedType.U4)] UInt32 channelNumber,
+            [Out][MarshalAs(UnmanagedType.R4)] out float level);
+
+        /// <summary>
+        /// Sets the muting state of the audio stream.
+        /// </summary>
+        /// <param name="isMuted">True to mute the stream, or false to unmute the stream.</param>
+        /// <param name="eventContext">A user context value that is passed to the notification callback.</param>
+        /// <returns>An HRESULT code indicating whether the operation passed of failed.</returns>
+        [PreserveSig]
+        int SetMute(
+            [In][MarshalAs(UnmanagedType.Bool)] Boolean isMuted,
+            [In][MarshalAs(UnmanagedType.LPStruct)] Guid eventContext);
+
+        /// <summary>
+        /// Gets the muting state of the audio stream.
+        /// </summary>
+        /// <param name="isMuted">The muting state. True if the stream is muted, false otherwise.</param>
+        /// <returns>An HRESULT code indicating whether the operation passed of failed.</returns>
+        [PreserveSig]
+        int GetMute(
+            [Out][MarshalAs(UnmanagedType.Bool)] out Boolean isMuted);
+
+        /// <summary>
+        /// Gets information about the current step in the volume range.
+        /// </summary>
+        /// <param name="step">The current zero-based step index.</param>
+        /// <param name="stepCount">The total number of steps in the volume range.</param>
+        /// <returns>An HRESULT code indicating whether the operation passed of failed.</returns>
+        [PreserveSig]
+        int GetVolumeStepInfo(
+            [Out][MarshalAs(UnmanagedType.U4)] out UInt32 step,
+            [Out][MarshalAs(UnmanagedType.U4)] out UInt32 stepCount);
+
+        /// <summary>
+        /// Increases the volume level by one step.
+        /// </summary>
+        /// <param name="eventContext">A user context value that is passed to the notification callback.</param>
+        /// <returns>An HRESULT code indicating whether the operation passed of failed.</returns>
+        [PreserveSig]
+        int VolumeStepUp(
+            [In][MarshalAs(UnmanagedType.LPStruct)] Guid eventContext);
+
+        /// <summary>
+        /// Decreases the volume level by one step.
+        /// </summary>
+        /// <param name="eventContext">A user context value that is passed to the notification callback.</param>
+        /// <returns>An HRESULT code indicating whether the operation passed of failed.</returns>
+        [PreserveSig]
+        int VolumeStepDown(
+            [In][MarshalAs(UnmanagedType.LPStruct)] Guid eventContext);
+
+        /// <summary>
+        /// Queries the audio endpoint device for its hardware-supported functions.
+        /// </summary>
+        /// <param name="hardwareSupportMask">A hardware support mask that indicates the capabilities of the endpoint.</param>
+        /// <returns>An HRESULT code indicating whether the operation passed of failed.</returns>
+        [PreserveSig]
+        int QueryHardwareSupport(
+            [Out][MarshalAs(UnmanagedType.U4)] out UInt32 hardwareSupportMask);
+
+        /// <summary>
+        /// Gets the volume range of the audio stream, in decibels.
+        /// </summary>
+		/// <param name="volumeMin">The minimum volume level in decibels.</param>
+		/// <param name="volumeMax">The maximum volume level in decibels.</param>
+		/// <param name="volumeStep">The volume increment level in decibels.</param>
+        /// <returns>An HRESULT code indicating whether the operation passed of failed.</returns>
+        [PreserveSig]
+        int GetVolumeRange(
+            [Out][MarshalAs(UnmanagedType.R4)] out float volumeMin,
+            [Out][MarshalAs(UnmanagedType.R4)] out float volumeMax,
+            [Out][MarshalAs(UnmanagedType.R4)] out float volumeStep);
+    }
+
+    #endregion
+}

FSI.Lib/FSI.Lib/FSI.Lib.csproj

@@ -5,6 +5,7 @@
 		<OutputType>Library</OutputType>
 		<GenerateAssemblyInfo>true</GenerateAssemblyInfo>
 		<UseWPF>true</UseWPF>
+		<UseWindowsForms>true</UseWindowsForms>
 		<ImportWindowsDesktopTargets>true</ImportWindowsDesktopTargets>
 		<AssemblyVersion>3.0</AssemblyVersion>
 	</PropertyGroup>
@@ -38,6 +39,7 @@
 	  <PackageReference Include="System.Configuration.ConfigurationManager" Version="6.0.0" />
 	  <PackageReference Include="System.Text.Encoding.CodePages" Version="7.0.0" />
 	  <PackageReference Include="TextCopy" Version="6.2.1" />
+		<PackageReference Include="System.ComponentModel.Composition" Version="7.0.0" />
 	</ItemGroup>
 	<ItemGroup>
 	  <ProjectReference Include="..\..\RoboSharp\RoboSharp.csproj" />

FSI.Lib/FSI.Lib/Guis/Rdp.Mgt/FrmMain.xaml

@@ -0,0 +1,181 @@
+<Window x:Class="FSI.Lib.Guis.Rdp.Mgt.FrmMain"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+        xmlns:local="clr-namespace:FSI.Lib.Guis.Rdp.Mgt"
+        xmlns:control="clr-namespace:FSI.Lib.Wpf.Ctrls.FilterDataGrid"
+        d:DataContext="{d:DesignInstance Type=local:ViewModel}"
+        mc:Ignorable="d"
+        SizeToContent="Width"
+        Height="800"
+        Width="Auto"
+        Icon="../../Icons/FondiumU.ico">
+    <Window.Resources>
+        <ObjectDataProvider x:Key="FilteredData"></ObjectDataProvider>
+    </Window.Resources>
+
+    <Window.InputBindings>
+        <KeyBinding Command="{Binding CmdOpen}"
+                    Gesture="CTRL+o" />
+    </Window.InputBindings>
+
+    <Grid FocusManager.FocusedElement="{Binding ElementName=tbSearch}">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="*" />
+        </Grid.RowDefinitions>
+
+        <Grid Grid.Row="0"
+              Margin="0,10"
+              HorizontalAlignment="Stretch">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="2*" />
+                <ColumnDefinition Width="1*" />
+            </Grid.ColumnDefinitions>
+
+            <StackPanel Grid.Column="0"
+                        HorizontalAlignment="Left"
+                        Orientation="Horizontal">
+                <Label Margin="0,0,20,0"
+                       VerticalAlignment="Bottom"
+                       Content="Suche:"
+                       FontWeight="Bold" />
+                <TextBox Name="tbSearch"
+                         Height="26"
+                         MinWidth="200"
+                         VerticalAlignment="Center"
+                         VerticalContentAlignment="Center"
+                         Text="{Binding Search, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
+                         TextChanged="tbSearch_TextChanged" />
+                <Button Width="Auto"
+                        Margin="5,0,0,0"
+                        Padding="4"
+                        Command="{Binding RefreshCommand}"
+                        ToolTip="Filter löschen"
+                        Cursor="Hand">
+                    <Image Source="../../Icons/Cross.png"
+                           Height="14" />
+                </Button>
+            </StackPanel>
+            <StackPanel Grid.Column="2"
+                        HorizontalAlignment="Right"
+                        Orientation="Horizontal">
+                <Button Width="Auto"
+                        Margin="0 0 20 0"
+                        Padding="4"
+                        ToolTip="öffen"
+                        Command="{Binding CmdOpen}"
+                        IsEnabled="{Binding CanExecuteOpen}"
+                        Cursor="Hand">
+                    <Image Source="../../Icons/Open.png"
+                           Height="14" />
+                </Button>
+            </StackPanel>
+        </Grid>
+
+        <StackPanel Grid.Row="1"
+                    HorizontalAlignment="Left"
+                    Orientation="Horizontal"
+                    Margin="0,5">
+            <Label Margin="0,0,20,0"
+                   VerticalAlignment="Bottom"
+                   Content="Quick-Filter:"
+                   FontWeight="Bold" />
+            <Button Width="Auto"
+                    Margin="5,0,0,0"
+                    Padding="4"
+                    ToolTip="Filter löschen"
+                    Command="{Binding RefreshCommand}"
+                    Cursor="Hand">
+                <Image Source="../../Icons/Cross.png"
+                       Height="14" />
+            </Button>
+            <Button Content="Alg"
+                    Width="Auto"
+                    Margin="10,0,0,0"
+                    ToolTip="Filter auf Alg"
+                    Command="{Binding CmdQuickSearch}"
+                    CommandParameter="Alg"
+                    FocusManager.FocusedElement="{Binding ElementName=tbSearch}" />
+            <Button Content="PL1"
+                    Width="Auto"
+                    Margin="10,0,0,0"
+                    ToolTip="Filter auf PL1"
+                    Command="{Binding CmdQuickSearch}"
+                    CommandParameter="PL1"
+                    FocusManager.FocusedElement="{Binding ElementName=tbSearch}" />
+            <Button Content="PL2"
+                    Width="Auto"
+                    Margin="10,0,0,0"
+                    ToolTip="Filter auf PL2"
+                    Command="{Binding CmdQuickSearch}"
+                    CommandParameter="PL2"
+                    FocusManager.FocusedElement="{Binding ElementName=tbSearch}" />
+            <Button Content="PL3"
+                    Width="Auto"
+                    Margin="10,0,0,0"
+                    ToolTip="Filter auf PL3"
+                    Command="{Binding CmdQuickSearch}"
+                    CommandParameter="PL3"
+                    FocusManager.FocusedElement="{Binding ElementName=tbSearch}" />
+            <Button Content="SMZ"
+                    Width="Auto"
+                    Margin="10,0,0,0"
+                    ToolTip="Filter auf SMZ"
+                    Command="{Binding CmdQuickSearch}"
+                    CommandParameter="SMZ"
+                    FocusManager.FocusedElement="{Binding ElementName=tbSearch}" />
+        </StackPanel>
+
+        <control:FilterDataGrid x:Name="FilterDataGrid"
+                                Grid.Row="2"
+                                AutoGenerateColumns="False"
+                                DateFormatString="d"
+                                FilterLanguage="German"
+                                ItemsSource="{Binding FilteredData, UpdateSourceTrigger=PropertyChanged}"
+                                SelectionMode="Single"
+                                SelectedItem="{Binding SelectedData, UpdateSourceTrigger=PropertyChanged}"
+                                ShowElapsedTime="false"
+                                ShowRowsCount="True"
+                                ShowStatusBar="True">
+
+            <control:FilterDataGrid.InputBindings>
+                <MouseBinding MouseAction="RightDoubleClick"
+                              Command="{Binding CmdCopyToClip}" />
+
+            </control:FilterDataGrid.InputBindings>
+            <control:FilterDataGrid.Columns>
+
+                <control:DataGridTemplateColumn FieldName="Plant"
+                                                Header="Anlage"
+                                                IsColumnFiltered="True"
+                                                SortMemberPath="Plant">
+                    <control:DataGridTemplateColumn.CellTemplate>
+                        <DataTemplate DataType="local:Interface">
+                            <TextBlock Text="{Binding Plant}" />
+                        </DataTemplate>
+                    </control:DataGridTemplateColumn.CellTemplate>
+                </control:DataGridTemplateColumn>
+
+                <control:DataGridTextColumn Binding="{Binding SubPlant}"
+                                            Header="Teilanlagen"
+                                            IsReadOnly="True"
+                                            IsColumnFiltered="True" />
+
+                <control:DataGridTextColumn Binding="{Binding Description}"
+                                            Header="Beschreibung"
+                                            IsReadOnly="True"
+                                            IsColumnFiltered="True" />
+
+                <control:DataGridTextColumn Binding="{Binding Host}"
+                                            Header="Host"
+                                            IsReadOnly="True"
+                                            IsColumnFiltered="True" />
+
+            </control:FilterDataGrid.Columns>
+        </control:FilterDataGrid>
+    </Grid>
+</Window>
+

FSI.Lib/FSI.Lib/Guis/Rdp.Mgt/FrmMain.xaml.cs

@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using System.Reflection;
+using System.Windows;
+using System.Windows.Controls;
+
+namespace FSI.Lib.Guis.Rdp.Mgt
+{
+    /// <summary>
+    /// Interaktionslogik für FrmMain.xaml
+    /// </summary>
+    public partial class FrmMain : Window
+    {
+        public ViewModel Rdps { get; set; }
+        public bool CloseAtLostFocus { get; set; }
+        public IEnumerable<IInterface> InputData { get; set; }
+
+        public string Exe { get; set; }
+
+        public FrmMain()
+        {
+            InitializeComponent();
+            Loaded += Main_Loaded;
+            Deactivated += FrmMain_Deactivated;
+        }
+
+        private void FrmMain_Deactivated(object sender, System.EventArgs e)
+        {
+            if (CloseAtLostFocus)
+                Visibility = Visibility.Hidden;
+        }
+
+        private void Main_Loaded(object sender, RoutedEventArgs e)
+        {
+
+            Title = "FSI Text in die Zwischenablage kopieren";
+            Title += " v" + Assembly.GetExecutingAssembly().GetName().Version; // Version in Titel eintragen
+
+            Rdps = new ViewModel(new DataProvider())
+            {
+                InputData = InputData,
+                Exe = Exe,
+            };
+            DataContext = Rdps;
+
+            Rdps.Load();
+        }
+
+        private void tbSearch_TextChanged(object sender, TextChangedEventArgs e)
+        {
+            tbSearch.Select(tbSearch.Text.Length, 0);
+        }
+
+    }
+}
+

FSI.Lib/FSI.Lib/Guis/Rdp.Mgt/Model.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+
+namespace FSI.Lib.Guis.Rdp.Mgt
+{
+    public interface IInterface
+    {
+        string Plant { get; set; }
+        string SubPlant { get; set; }
+        string Description { get; set; }
+        string Host { get; set; }
+    }
+
+    public struct Model : IInterface
+    {
+        private string _plant;
+        private string _subPlant;
+        private string _description;
+        private string _host;
+        public string Plant { get => _plant; set => _plant = value; }
+        public string SubPlant { get => _subPlant; set => _subPlant = value; }
+        public string Description { get => _description; set => _description = value; }
+        public string Host { get => _host; set => _host = value; }
+        public string DescriptionDtl { get => _plant + " " + SubPlant + " " + Description + " " + Host; }
+    }
+
+    public interface IDataProvider
+    {
+        IEnumerable<Model> Load(IEnumerable<IInterface> datas);
+    }
+}

FSI.Lib/FSI.Lib/Guis/Rdp.Mgt/ViewModel.cs

@@ -0,0 +1,187 @@
+using FSI.Lib.MVVM;
+using Microsoft.Extensions.Logging;
+using NLog;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Windows.Data;
+using System.Windows.Input;
+
+namespace FSI.Lib.Guis.Rdp.Mgt
+{
+    public class ViewModel : MVVM.ViewModelBase
+    {
+        readonly IDataProvider _dataProvider;
+        private string _search;
+        private ICollectionView _collView;
+
+        public ICommand RefreshCommand => new DelegateCommand(RefreshData);
+        private ICommand _cmdQuickSearch;
+        private ICommand _cmdOpen;
+
+        public Logger _log;
+
+        public ViewModel(IDataProvider dataProvider)
+        {
+            Datas = new ObservableCollection<Model>();
+            _dataProvider = dataProvider;
+
+            _cmdQuickSearch = new RelayCommand<object>(ExecuteQuickSearch, CanExecuteQuickSearch);
+            _cmdOpen = new RelayCommand<object>(ExecuteOpen, CanExecuteOpen);
+
+            _log = LogManager.GetCurrentClassLogger();
+        }
+
+        public ObservableCollection<Model> Datas { get; }
+        public ObservableCollection<Model> FilteredData { get; set; }
+
+        public Model SelectedData { get; set; }
+
+        public IEnumerable<IInterface> InputData { get; set; }
+
+        public string Exe { get; set; }
+        public void Load()
+        {
+            var datas = _dataProvider.Load(InputData);
+            Datas.Clear();
+
+            if (datas != null)
+            {
+                foreach (Model data in datas)
+                {
+                    Datas.Add(data);
+                }
+            }
+
+            FilteredData = new ObservableCollection<Model>(Datas);
+            _collView = CollectionViewSource.GetDefaultView(FilteredData);
+        }
+
+        public string Search
+        {
+            get => _search;
+            set
+            {
+                _search = value;
+
+                _collView.Filter = e =>
+                {
+                    var item = (Model)e;
+
+                    return ((item.Plant?.StartsWith(_search, StringComparison.OrdinalIgnoreCase) ?? false)
+                                                || (item.SubPlant?.StartsWith(_search, StringComparison.OrdinalIgnoreCase) ?? false)
+#if NET472
+                                                || (item.Path?.Contains(_search) ?? false)
+                                                || (item.DescriptionDtl?.Contains(_search) ?? false)
+#elif NET6_0
+                                                || (item.Host?.Contains(_search, StringComparison.OrdinalIgnoreCase) ?? false)
+                                                || (item.DescriptionDtl?.Contains(_search, StringComparison.OrdinalIgnoreCase) ?? false)
+#endif
+                                                );
+                };
+
+                _collView.Refresh();
+                FilteredData = new ObservableCollection<Model>(_collView.OfType<Model>().ToList());
+                OnPropertyChanged();
+            }
+        }
+
+        public void QuickSearch(string search)
+        {
+            Search = search + " ";
+        }
+
+        private void RefreshData(object obj)
+        {
+            Search = string.Empty;
+        }
+
+        private bool CanExecuteQuickSearch(object obj)
+        {
+            return true;
+        }
+
+        private void ExecuteQuickSearch(object obj)
+        {
+            QuickSearch(obj.ToString());
+        }
+
+        public ICommand CmdQuickSearch
+        {
+            get { return _cmdQuickSearch; }
+            set => _cmdQuickSearch = value;
+        }
+
+        private bool CanExecuteOpen(object obj)
+        {
+            if (SelectedData.Host != null)
+                return true;
+            else
+                return false;
+        }
+
+        private void ExecuteOpen(object obj)
+        {
+
+            Process process = new();
+            process.StartInfo.FileName = Environment.ExpandEnvironmentVariables(Exe);
+            process.StartInfo.WorkingDirectory =  Path.GetDirectoryName(Environment.ExpandEnvironmentVariables(Exe));
+            process.StartInfo.Arguments = "/v:" + SelectedData.Host + " " + "/f";
+
+            try
+            {
+
+                process.Start();
+                _log.Info("Anwendung \"{0}\" wurde mit den Argumenten \"{1}\" gestartet", Exe, process.StartInfo.Arguments);
+            }
+            catch (System.ComponentModel.Win32Exception ex) when (ex.NativeErrorCode == 740)
+            {
+                try
+                {
+                    process.StartInfo.UseShellExecute = true;
+                    process.StartInfo.Verb = "runas";
+                    process.Start();
+                    _log.Info("Anwendung \"{0}\" wurde mit den Argumenten \"{1}\" als Admin gestartet", Exe, process.StartInfo.Arguments);
+                }
+                catch (Exception ex2)
+                {
+                   _log.Info("Anwendung konnte durch folgenden Fehler \"{0}\" nicht gestartet werden.", ex2.Message);
+                }
+            }
+
+        }
+
+        public ICommand CmdOpen
+        {
+            get { return _cmdOpen; }
+            set => _cmdOpen = value;
+        }
+    }
+
+    public class DataProvider : IDataProvider
+    {
+        public IEnumerable<Model> Load(IEnumerable<IInterface> datas)
+        {
+            var newDatas = new ObservableCollection<Model>();
+
+            foreach (IInterface data in datas)
+            {
+                Model newData = new();
+                
+                newData.Plant = data.Plant;
+                newData.SubPlant = data.SubPlant;
+                newData.Description = data.Description;
+                newData.Host = data.Host;
+
+                newDatas.Add(newData);
+            }
+
+            newDatas = new ObservableCollection<Model>(newDatas.OrderBy(i => i.DescriptionDtl));
+            return newDatas;
+        }
+    }
+}

FSI.Lib/FSI.Lib/Guis/SieTiaWinCCMsgMgt/ViewModel.cs

@@ -32,13 +32,11 @@ namespace FSI.Lib.Guis.SieTiaWinCCMsgMgt
         static extern bool IsWindowVisible(IntPtr hWnd);
 
         const int BM_CLICK = 0x00F5; //message for Click which is a constant
-        const int WM_LBUTTONDOWN = 0x0201; //message for Mouse down
-        const int WM_LBUTTONUP = 0x0202; // message for Mouse up
-
+ 
         private CancellationTokenSource tokenSource = null;
         private Task task = null;
 
-        private BackgroundWorker backgroundWorker;
+        private readonly BackgroundWorker backgroundWorker;
         private ICommand _cmdStart;
         private ICommand _cmdStop;