diff --git a/FlyleafLib.Controls.WPF/Config.cs b/FlyleafLib.Controls.WPF/Config.cs
index 5e74b746..577a1919 100644
--- a/FlyleafLib.Controls.WPF/Config.cs
+++ b/FlyleafLib.Controls.WPF/Config.cs
@@ -19,6 +19,8 @@ public ObservableCollection<UITheme>
         public string       SelectedTheme   { get => _SelectedTheme;    set => Set(ref _SelectedTheme, value); }
         string _SelectedTheme;
 
+        public int          ActivityTimeout { get; set; } // we just store it to file
+
         public string       SubsFontFamily  { get => _SubsFontFamily;   set => Set(ref _SubsFontFamily, value); }
         string _SubsFontFamily;
         public double       SubsFontSize    { get => _SubsFontSize;     set => Set(ref _SubsFontSize, value); }
@@ -45,7 +47,7 @@ public static void Load(FlyleafME flyleaf, string path)
             {
                 XmlSerializer xmlSerializer = new XmlSerializer(typeof(UIConfig));
                 flyleaf.UIConfig = (UIConfig) xmlSerializer.Deserialize(fs);
-
+                flyleaf.ActivityTimeout = flyleaf.UIConfig.ActivityTimeout;
                 flyleaf.UIConfig.Loaded = true;
                 flyleaf.UIConfig.flyleaf = flyleaf;
                 foreach(var theme in flyleaf.UIConfig.Themes)
@@ -56,11 +58,14 @@ public static void Load(FlyleafME flyleaf, string path)
         public static void Save(FlyleafME flyleaf, string uiConfigPath, string configPath, string enginePath)
         {
             if (uiConfigPath != null)
+            {
+                flyleaf.UIConfig.ActivityTimeout = flyleaf.ActivityTimeout;
                 using (FileStream fs = new FileStream(uiConfigPath, FileMode.Create))
                 {
                     XmlSerializer xmlSerializer = new XmlSerializer(typeof(UIConfig));
                     xmlSerializer.Serialize(fs, flyleaf.UIConfig);
                 }
+            }
 
             if (configPath != null)
                 flyleaf.Config.Save(configPath);
diff --git a/FlyleafLib.Controls.WPF/FlyleafLib.Controls.WPF.csproj b/FlyleafLib.Controls.WPF/FlyleafLib.Controls.WPF.csproj
index 1364f017..2795d199 100644
--- a/FlyleafLib.Controls.WPF/FlyleafLib.Controls.WPF.csproj
+++ b/FlyleafLib.Controls.WPF/FlyleafLib.Controls.WPF.csproj
@@ -4,7 +4,7 @@
     <TargetFrameworks>net6.0-windows;net5.0-windows;net472</TargetFrameworks>
 	<UseWindowsForms>true</UseWindowsForms>
     <UseWPF>true</UseWPF>
-    <Version>1.2-pre</Version>
+    <Version>1.2-pre2</Version>
     <Authors>SuRGeoNix</Authors>
     <Copyright>SuRGeoNix © 2022</Copyright>
     <PackageLicenseExpression>LGPL-3.0-or-later</PackageLicenseExpression>
@@ -14,15 +14,9 @@
     <PackageTags>flyleaf flyleaflib video audio media player element control</PackageTags>
     <Description>WPF Media Player Control/Element (based on FlyleafLib)</Description>
     <PackageReleaseNotes>
-		- Introduces FlyleafME WPF Media Element Control (WPF Flyleaf Control replacement)
-		* Updated with the new FlyleafHost and gains better performance
-		* Resolves several issues with DPI
-		* Code clean-up and styles to allow easier override and customization
+		* Fixes an issue to respect Subtitles FontStyle
+		* Adds Activity Timeout on Settings
 		* Updates FlyleafLib
-
-		- Breaking Changes
-		* Flyleaf (WPF Control) has been renamed to FlyleafME (Media Element) and does not require a FlyleafHost as it was required previously with the VideoView (it derives from it)
-		* See WPF/FlyleafHost.cs for the new dependency properties and customization
 	</PackageReleaseNotes>
   </PropertyGroup>
 
diff --git a/FlyleafLib.Controls.WPF/FlyleafME.cs b/FlyleafLib.Controls.WPF/FlyleafME.cs
index 75caeeed..25e0d9f3 100644
--- a/FlyleafLib.Controls.WPF/FlyleafME.cs
+++ b/FlyleafLib.Controls.WPF/FlyleafME.cs
@@ -74,9 +74,6 @@ public SerializableDictionary<string, SerializableDictionary<string, string>>
         public bool         CanPaste            { get => _CanPaste; set => Set(ref _CanPaste, value); }
         bool _CanPaste;
 
-        public string       SubtitlesFontDesc   { get => _SubtitlesFontDesc; set => Set(ref _SubtitlesFontDesc, value); }
-        string _SubtitlesFontDesc;
-
         public UITheme SelectedTheme
         {
             get => _SelectedTheme;
@@ -309,7 +306,6 @@ private void Initialize()
                 if (uitheme.Name == UIConfig.SelectedTheme)
                     SelectedTheme = uitheme;
 
-            SubtitlesFontDesc = $"{UIConfig.SubsFontFamily} ({UIConfig.SubsFontWeight}), {UIConfig.SubsFontSize}";
             subsInitialMargin   = UIConfig.SubsMargin;
 
             if (popUpMenu != null)
@@ -433,8 +429,8 @@ public async void OpenSettingsAction(object obj = null)
 
             Player.Activity.IsEnabled = false;
 
-            var prevKeys = KeyBindingsMode;
-            KeyBindingsMode = AvailableWindows.None;
+            var prevKeys = KeyBindings;
+            KeyBindings = AvailableWindows.None;
 
             Dictionary<VideoFilters, int> saveFilterValues = new Dictionary<VideoFilters, int>();
             foreach(var filter in Config.Video.Filters.Values)
@@ -444,7 +440,7 @@ public async void OpenSettingsAction(object obj = null)
             var result = await DialogHost.Show(settings, dialogSettingsIdentifier);
 
             Player.Activity.IsEnabled = true;
-            KeyBindingsMode = prevKeys;
+            KeyBindings = prevKeys;
 
             if (result == null) return;
 
@@ -530,8 +526,6 @@ public void SetSubtitlesFontAction(object obj = null)
                 UIConfig.SubsFontStretch= dialog.Font.Stretch.ToString();
                 UIConfig.SubsFontStyle  = dialog.Font.Style.ToString();
                 UIConfig.SubsFontColor  = dialog.Font.BrushColor.Color;
-
-                SubtitlesFontDesc       = $"{UIConfig.SubsFontFamily} ({UIConfig.SubsFontWeight}), {UIConfig.SubsFontSize}";
             }
         }
         #endregion
diff --git a/FlyleafLib.Controls.WPF/Settings.xaml b/FlyleafLib.Controls.WPF/Settings.xaml
index 6f0f8e7b..72c31fba 100644
--- a/FlyleafLib.Controls.WPF/Settings.xaml
+++ b/FlyleafLib.Controls.WPF/Settings.xaml
@@ -191,7 +191,8 @@
                         </StackPanel>
                     </TabItem.Header>
                     <Grid>
-                        <Grid Margin="20" VerticalAlignment="Top">
+                        <ScrollViewer Height="270" Margin="20 20 20 0" VerticalAlignment="Top">
+                            <Grid>
                             <Grid.ColumnDefinitions>
                                 <ColumnDefinition Width="200"/>
                                 <ColumnDefinition Width="100"/>
@@ -207,34 +208,39 @@
                                 <RowDefinition Height="30"/>
                                 <RowDefinition Height="30"/>
                                 <RowDefinition Height="30"/>
+                                <RowDefinition Height="30"/>
                             </Grid.RowDefinitions>
+                            
+                            <TextBlock Grid.Row="0" Text="Idle Timeout (ms)" VerticalAlignment="Center"/>
+                            <TextBox   Grid.Row="0" Grid.Column="1" Style="{StaticResource FLTextboxNP}" Text="{Binding ActivityTimeout, UpdateSourceTrigger=Explicit}"/>
 
-                            <TextBlock Grid.Row="0" Text="Read Timeout (ms)" VerticalAlignment="Center"/>
-                            <TextBox   Grid.Row="0" Grid.Column="1" Style="{StaticResource FLTextboxNP}" Text="{Binding Config.Demuxer.ReadTimeout, UpdateSourceTrigger=Explicit, Converter={StaticResource TicksToMilliSeconds}}"/>
+                            <TextBlock Grid.Row="1" Text="Read Timeout (ms)" VerticalAlignment="Center"/>
+                            <TextBox   Grid.Row="1" Grid.Column="1" Style="{StaticResource FLTextboxNP}" Text="{Binding Config.Demuxer.ReadTimeout, UpdateSourceTrigger=Explicit, Converter={StaticResource TicksToMilliSeconds}}"/>
                             
-                            <TextBlock Grid.Row="1" Text="Buffer Duration Min.  (ms)" VerticalAlignment="Center"/>
-                            <TextBox   Grid.Row="1" Grid.Column="1" Style="{StaticResource FLTextboxNP}" Text="{Binding Config.Player.MinBufferDuration, UpdateSourceTrigger=Explicit, Converter={StaticResource TicksToMilliSeconds}}"/>
+                            <TextBlock Grid.Row="2" Text="Buffer Duration Min. (ms)" VerticalAlignment="Center"/>
+                            <TextBox   Grid.Row="2" Grid.Column="1" Style="{StaticResource FLTextboxNP}" Text="{Binding Config.Player.MinBufferDuration, UpdateSourceTrigger=Explicit, Converter={StaticResource TicksToMilliSeconds}}"/>
 
-                            <TextBlock Grid.Row="2" Text="Buffer Duration Max. (ms)" VerticalAlignment="Center"/>
-                            <TextBox   Grid.Row="2" Grid.Column="1" Style="{StaticResource FLTextboxNP}" Text="{Binding Config.Demuxer.BufferDuration, UpdateSourceTrigger=Explicit, Converter={StaticResource TicksToMilliSeconds}}"/>
+                            <TextBlock Grid.Row="3" Text="Buffer Duration Max. (ms)" VerticalAlignment="Center"/>
+                            <TextBox   Grid.Row="3" Grid.Column="1" Style="{StaticResource FLTextboxNP}" Text="{Binding Config.Demuxer.BufferDuration, UpdateSourceTrigger=Explicit, Converter={StaticResource TicksToMilliSeconds}}"/>
 
-                            <TextBlock Grid.Row="3" Text="Audio Frames Max." VerticalAlignment="Center"/>
-                            <TextBox   Grid.Row="3" Grid.Column="1" Style="{StaticResource FLTextboxNP}" Text="{Binding Config.Decoder.MaxAudioFrames, UpdateSourceTrigger=Explicit}"/>
+                            <TextBlock Grid.Row="4" Text="Audio Frames Max." VerticalAlignment="Center"/>
+                            <TextBox   Grid.Row="4" Grid.Column="1" Style="{StaticResource FLTextboxNP}" Text="{Binding Config.Decoder.MaxAudioFrames, UpdateSourceTrigger=Explicit}"/>
 
-                            <TextBlock Grid.Row="4" Text="Video Frames Max." VerticalAlignment="Center"/>
-                            <TextBox   Grid.Row="4" Grid.Column="1" Style="{StaticResource FLTextboxNP}" Text="{Binding Config.Decoder.MaxVideoFrames, UpdateSourceTrigger=Explicit}"/>
+                            <TextBlock Grid.Row="5" Text="Video Frames Max." VerticalAlignment="Center"/>
+                            <TextBox   Grid.Row="5" Grid.Column="1" Style="{StaticResource FLTextboxNP}" Text="{Binding Config.Decoder.MaxVideoFrames, UpdateSourceTrigger=Explicit}"/>
 
-                            <Separator Grid.Row="5" Grid.ColumnSpan="3"/>
+                            <Separator Grid.Row="6" Grid.ColumnSpan="3"/>
 
-                            <TextBlock Grid.Row="6" Text="Log File" VerticalAlignment="Center"/>
-                            <TextBox   Grid.Row="6" Grid.Column="1" Grid.ColumnSpan="2" Width="260" TextAlignment="Left" Style="{StaticResource FLTextbox}" Text="{Binding ConfigEngine.LogOutput, UpdateSourceTrigger=Explicit}"/>
+                            <TextBlock Grid.Row="7" Text="Log File" VerticalAlignment="Center"/>
+                            <TextBox   Grid.Row="7" Grid.Column="1" Grid.ColumnSpan="2" Width="260" TextAlignment="Left" Style="{StaticResource FLTextbox}" Text="{Binding ConfigEngine.LogOutput, UpdateSourceTrigger=Explicit}"/>
 
-                            <TextBlock Grid.Row="7" Text="Log Level" VerticalAlignment="Center"/>
-                            <ComboBox  Grid.Row="7" Grid.Column="1" ItemsSource="{Binding Source={StaticResource LogLevelEnum}}" SelectedItem="{Binding ConfigEngine.LogLevel}"/>
+                            <TextBlock Grid.Row="8" Text="Log Level" VerticalAlignment="Center"/>
+                            <ComboBox  Grid.Row="8" Grid.Column="1" ItemsSource="{Binding Source={StaticResource LogLevelEnum}}" SelectedItem="{Binding ConfigEngine.LogLevel}"/>
 
-                            <TextBlock Grid.Row="8" Text="Log Level (FFmpeg)" VerticalAlignment="Center"/>
-                            <ComboBox  Grid.Row="8" Grid.Column="1" ItemsSource="{Binding Source={StaticResource FFmpegLogLevelEnum}}" SelectedItem="{Binding ConfigEngine.FFmpegLogLevel}"/>
+                            <TextBlock Grid.Row="9" Text="Log Level (FFmpeg)" VerticalAlignment="Center"/>
+                            <ComboBox  Grid.Row="9" Grid.Column="1" ItemsSource="{Binding Source={StaticResource FFmpegLogLevelEnum}}" SelectedItem="{Binding ConfigEngine.FFmpegLogLevel}"/>
                         </Grid>
+                        </ScrollViewer>
                         <StackPanel Margin="0, 0, 0, 10" Orientation="Horizontal" HorizontalAlignment="Center" VerticalAlignment="Bottom">
                             <Button Style="{StaticResource SaveButton}"/>
                             <Button Content="Apply" FontWeight="ExtraBold" Command="{x:Static materialDesign:DialogHost.CloseDialogCommand}" CommandParameter="apply"/>
@@ -317,7 +323,13 @@
                             <Button Margin=" 0 15 0 0" Grid.Row="4" Grid.Column="1" Height="auto" MaxHeight="100" Command="{Binding SetSubtitlesFont}">
                                 <StackPanel Orientation="Horizontal" Margin="0 5 0 5">
                                     <Rectangle Margin=" 0 0 10 0" Width="18" Height="18" Fill="{Binding UIConfig.SubsFontColor, Converter={StaticResource ColorToBrush}}"/>
-                                    <TextBlock Text="{Binding SubtitlesFontDesc}" TextWrapping="Wrap" MaxWidth="200" VerticalAlignment="Center"/>
+                                    <TextBlock TextWrapping="Wrap" MaxWidth="200" VerticalAlignment="Center">
+                                        <Run Text="{Binding UIConfig.SubsFontFamily}"/>
+                                        <Run Text="("/>
+                                        <Run Text="{Binding UIConfig.SubsFontWeight}"/>
+                                        <Run Text="), "/>
+                                        <Run Text="{Binding UIConfig.SubsFontSize}"/>
+                                    </TextBlock>
                                 </StackPanel>
                             </Button>
                         </Grid>
diff --git a/FlyleafLib.Controls.WPF/Themes/FlyleafME.xaml b/FlyleafLib.Controls.WPF/Themes/FlyleafME.xaml
index 5369122b..0b9b291a 100644
--- a/FlyleafLib.Controls.WPF/Themes/FlyleafME.xaml
+++ b/FlyleafLib.Controls.WPF/Themes/FlyleafME.xaml
@@ -10,7 +10,7 @@
     
     <Style TargetType="{x:Type flwpf:FlyleafME}" BasedOn="{StaticResource {x:Type fl:FlyleafHost}}" x:Shared="False">
         <Setter Property="ActivityTimeout" Value="6000"/>
-        <Setter Property="KeyBindingsMode" Value="Both"/>
+        <Setter Property="KeyBindings" Value="Both"/>
         <Setter Property="Content">
             <Setter.Value>
                 <Border BorderThickness="0.6">
@@ -57,7 +57,7 @@
                             <fl:PlayerDebug VerticalAlignment="Center" HorizontalAlignment="Center" Player="{Binding Player}" BoxColor="#AA000000" HeaderColor="White" InfoColor="{DynamicResource PrimaryHueLightBrush}" ValueColor="{DynamicResource SecondaryHueLightBrush}" Visibility="{Binding ShowDebug, Converter={StaticResource BooleanToVisibility}, FallbackValue=Collapsed, TargetNullValue=Collapsed}"/>
 
                             <!--Subtitles-->
-                            <TextBlock Margin="{Binding UIConfig.SubsMargin}" VerticalAlignment="Bottom" HorizontalAlignment="Center" TextAlignment="Center" TextWrapping="Wrap" FontFamily="{Binding UIConfig.SubsFontFamily}" FontSize="{Binding UIConfig.SubsFontSize}" Foreground="{Binding UIConfig.SubsFontColor, Converter={StaticResource ColorToBrush}}" FontWeight="{Binding UIConfig.SubsFontWeight}" Text="{Binding Player.Subtitles.SubsText}">
+                            <TextBlock Margin="{Binding UIConfig.SubsMargin}" VerticalAlignment="Bottom" HorizontalAlignment="Center" TextAlignment="Center" TextWrapping="Wrap" FontFamily="{Binding UIConfig.SubsFontFamily}" FontSize="{Binding UIConfig.SubsFontSize}" Foreground="{Binding UIConfig.SubsFontColor, Converter={StaticResource ColorToBrush}}" FontWeight="{Binding UIConfig.SubsFontWeight}" FontStyle="{Binding UIConfig.SubsFontStyle}" Text="{Binding Player.Subtitles.SubsText}">
                                 <TextBlock.Effect>
                                     <DropShadowEffect ShadowDepth="2" Direction="0" Color="{Binding Player.Config.Video.BackgroundColor}" Opacity="1.0" BlurRadius="0"/>
                                 </TextBlock.Effect>
@@ -74,7 +74,7 @@
     
     <Style TargetType="{x:Type flwpf:FlyleafME}" BasedOn="{StaticResource {x:Type fl:FlyleafHost}}" x:Key="TBR123">
         <Setter Property="ActivityTimeout" Value="6000"/>
-        <Setter Property="KeyBindingsMode" Value="Both"/>
+        <Setter Property="KeyBindings" Value="Both"/>
         <Setter Property="Template">
             <Setter.Value>
                 <ControlTemplate TargetType="{x:Type flwpf:FlyleafME}">
diff --git a/FlyleafLib/Controls/WPF/FlyleafHost.cs b/FlyleafLib/Controls/WPF/FlyleafHost.cs
index 0310d41d..741b0d4b 100644
--- a/FlyleafLib/Controls/WPF/FlyleafHost.cs
+++ b/FlyleafLib/Controls/WPF/FlyleafHost.cs
@@ -19,73 +19,83 @@ namespace FlyleafLib.Controls.WPF
 {
     public class FlyleafHost : ContentControl, IDisposable
     {
-        /* Properties
-         * ----------
-         * 
-         * Player                   * Assigned Player (Can be changed or even be null)
-         * 
-         * KeyBindingsMode          * Disabled / Surface / Overlay / Both
-         * 
-         * AllowDrop                * File / Text Drop for Player
-         *                          * Swap FlyleafHosts (Shift)
-         *                  
-         * DragMoveOnAttach         * Drag Move Owner (Main Window)
-         *                          * Drag Move FlyleafHost
-         *                          
-         * DragMoveOnDetach         * Drag Move Surface (+Overlay)
-         *                  
-         * PanMove                  * Drag Move of Player's Pan & Zoom (wheel)
-         * 
-         * ResizeMode               * Allow Surface/Overlay to be resized
-         * 
-         * ResizeOnAttach           * Allow resize on attached
-         * 
-         * ResizeOnDetach           * Allow resize on detached
-         * 
-         * IsAttached               * Attach/Detach toggle
-         * 
-         * IsFullScreen             * Normal/Full toggle
-         * 
-         * IsResizing               * Whether Surface/Overlay is resizing
-         * 
-         * RememberLastDetachedRect * Restores detached surface to last position/size
-         * 
-         * DetachedRect             * Position and size of the detached surface
-         * 
-         * TopMost                  * Keeps surface on top
-         * 
-         * ToggleFullScreenOnDoubleClick
-         *                          * Toggle full screen
-         * 
-         * Content (Overlay)        * Will be transfered to Overlay by default
-         * 
-         * Detached Content         * FlyleafHost's actual content
+        /* -= FlyleafHost Properties Notes =-
+
+            Player							[Can be changed, can be null]
+
+            Surface							[ReadOnly / Required]
+            Overlay							[AutoCreated OnContentChanged | Provided directly | Provided in Stand Alone Constructor]
+
+            Content							[Overlay's Content]
+            DetachedContent					[Host's actual content]
+
+            DataContext						[Set by the user or default inheritance]
+            HostDataContext					[Will be set Sync with DataContext as helper to Overlay when we pass this as Overlay's DataContext]
+
+            OpenOnDrop						[None, Surface, Overlay, Both]		| Requires AllowDrop and Player
+            SwapOnDrop						[None, Surface, Overlay, Both]		| Requires AllowDrop and Player
+
+            SwapDragEnterWithShift			[None, Surface, Overlay, Both]		| Requires SwapOnDrop and Player
+            ToggleFullScreenOnDoubleClick	[None, Surface, Overlay, Both]
+
+            PanMoveWithCtrl					[None, Surface, Overlay, Both]		| Requires Player and VideoStream Opened
+            PanZoomWithCtrlWheel			[None, Surface, Overlay, Both]		| Requires Player and VideoStream Opened
+
+            AttachedDragMove				[None, Surface, Overlay, Both, SurfaceOwner, OverlayOwner, BothOwner]
+            DetachedDragMove				[None, Surface, Overlay, Both]
+
+            AttachedResize					[None, Surface, Overlay, Both]
+            DetachedResize					[None, Surface, Overlay, Both]
+            KeepRatioOnResize				[False, True]
+            CurResizeRatio                  [0 if not Keep Ratio or Player's aspect ratio]
+            ResizeSensitivity               Pixels sensitivity from the window's edges
+
+            DetachedPosition				[Custom, TopLeft, TopCenter, TopRight, CenterLeft, CenterCenter, CenterRight, BottomLeft, BottomCenter, BottomRight]
+            DetachedPositionMargin			[X, Y, CX, CY]						| Does not affect the Size / Eg. No point to provide both X/CX 	
+            DetachedFixedPosition			[X, Y]								| If not set same as attached, if remember only first time
+            DetachedFixedSize				[CX, CY]							| If not set same as attached, if remember only first time
+            DetachedRememberPosition		[False, True]
+            DetachedRememberSize			[False, True]
+            DetachedTopMost					[False, True] (Surfaces Only Required?)
+
+            KeyBindings						[None, Surface, Overlay, Both]
+
+            ActivityTimeout					[0: Disabled]						| Requires Player?
+            ActivityRefresh?				[None, Surface, Overlay, Both]		| MouseMove / MouseDown / KeyUp
+
+            PassWheelToOwner?				[None, Surface, Overlay, Both]		| When host belongs to ScrollViewer
+
+            IsAttached
+            IsFullScreen
+            IsResizing						[ReadOnly]
+            IsSwapping						[ReadOnly]
+            IsStandAlone					[ReadOnly]
+         */
+
+        /* TODO
+         * 1) The surface / overlay events code is repeated
+         * 2) PassWheelToOwner (Related with LayoutUpdate performance / ScrollViewer) / ActivityRefresh
+         * 3) Review Content/DetachedContent/Template logic
+         * 4) Attach to different Owner (Load/Unload) and change Overlay?
          */
 
         #region Properties / Variables
-        public Window       Surface         { get; private set; }
         public Window       Owner           { get; private set; }
-
+        public Window       Surface         { get; private set; }
         public IntPtr       SurfaceHandle   { get; private set; }
         public IntPtr       OverlayHandle   { get; private set; }
         public IntPtr       OwnerHandle     { get; private set; }
-
-        public bool         Disposed        { get; private set; }
-        public int          UniqueId        { get; private set; } = -1;
-
         public int          ResizingSide    { get; private set; }
-        public int          ResizingSideOverlay
-                                            { get; private set; }
 
-        public bool         IsSwaping       { get; private set; }
+        public int          UniqueId        { get; private set; }
+        public bool         Disposed        { get; private set; }
 
+        static int idGenerator;
         bool isSurfaceClosing;
-        bool isStandAlone;
         static bool isDesginMode;
         Grid dMain, dHost, dSurface, dOverlay; // Design Mode Grids
         bool preventContentUpdate;
         int panPrevX, panPrevY;
-        bool mouseLeftDownDeactivated;
         bool preventFullScreenUpdate; // to handle a bug from fullscreen to minimize and back to normal
 
         Matrix matrix;
@@ -103,93 +113,186 @@ private class FlyleafHostDropWrap { public FlyleafHost FlyleafHost; } // To allo
         #endregion
 
         #region Dependency Properties
-        public int ActivityTimeout
+        public AvailableWindows OpenOnDrop
         {
-            get { return (int)GetValue(ActivityTimeoutProperty); }
-            set { SetValue(ActivityTimeoutProperty, value); }
+            get { return (AvailableWindows)GetValue(OpenOnDropProperty); }
+            set { SetValue(OpenOnDropProperty, value); }
         }
-        public static readonly DependencyProperty ActivityTimeoutProperty =
-            DependencyProperty.Register(nameof(ActivityTimeout), typeof(int), typeof(FlyleafHost), new PropertyMetadata(0, new PropertyChangedCallback(OnActivityTimeoutChanged)));
+        public static readonly DependencyProperty OpenOnDropProperty =
+            DependencyProperty.Register(nameof(OpenOnDrop), typeof(AvailableWindows), typeof(FlyleafHost), new PropertyMetadata(AvailableWindows.Surface, new PropertyChangedCallback(DropChanged)));
+        
+        public AvailableWindows SwapOnDrop
+        {
+            get { return (AvailableWindows)GetValue(SwapOnDropProperty); }
+            set { SetValue(SwapOnDropProperty, value); }
+        }
+        public static readonly DependencyProperty SwapOnDropProperty =
+            DependencyProperty.Register(nameof(SwapOnDrop), typeof(AvailableWindows), typeof(FlyleafHost), new PropertyMetadata(AvailableWindows.Surface, new PropertyChangedCallback(DropChanged)));
 
-        public AttachedDragMoveMode DragMoveOnAttach
+        public AvailableWindows SwapDragEnterWithShift
         {
-            get { return (AttachedDragMoveMode)GetValue(DragMoveOnAttachProperty); }
-            set { SetValue(DragMoveOnAttachProperty, value); }
+            get { return (AvailableWindows)GetValue(SwapDragEnterWithShiftProperty); }
+            set { SetValue(SwapDragEnterWithShiftProperty, value); }
         }
-        public static readonly DependencyProperty DragMoveOnAttachProperty =
-            DependencyProperty.Register(nameof(DragMoveOnAttach), typeof(AttachedDragMoveMode), typeof(FlyleafHost), new PropertyMetadata(AttachedDragMoveMode.Owner));
+        public static readonly DependencyProperty SwapDragEnterWithShiftProperty =
+            DependencyProperty.Register(nameof(SwapDragEnterWithShift), typeof(AvailableWindows), typeof(FlyleafHost), new PropertyMetadata(AvailableWindows.Surface));
 
-        public bool DragMoveOnDetach
+        public AvailableWindows ToggleFullScreenOnDoubleClick
         {
-            get { return (bool)GetValue(DragMoveOnDetachProperty); }
-            set { SetValue(DragMoveOnDetachProperty, value); }
+            get { return (AvailableWindows)GetValue(ToggleFullScreenOnDoubleClickProperty); }
+            set { SetValue(ToggleFullScreenOnDoubleClickProperty, value); }
         }
-        public static readonly DependencyProperty DragMoveOnDetachProperty =
-            DependencyProperty.Register(nameof(DragMoveOnDetach), typeof(bool), typeof(FlyleafHost), new PropertyMetadata(true));
+        public static readonly DependencyProperty ToggleFullScreenOnDoubleClickProperty =
+            DependencyProperty.Register(nameof(ToggleFullScreenOnDoubleClick), typeof(AvailableWindows), typeof(FlyleafHost), new PropertyMetadata(AvailableWindows.Surface));
 
-        public FrameworkElement MarginTarget
+        public AvailableWindows PanMoveWithCtrl
         {
-            get { return (FrameworkElement)GetValue(MarginTargetProperty); }
-            set { SetValue(MarginTargetProperty, value); }
+            get { return (AvailableWindows)GetValue(PanMoveWithCtrlProperty); }
+            set { SetValue(PanMoveWithCtrlProperty, value); }
         }
-        public static readonly DependencyProperty MarginTargetProperty =
-            DependencyProperty.Register(nameof(MarginTarget), typeof(FrameworkElement), typeof(FlyleafHost), new PropertyMetadata(null));
+        public static readonly DependencyProperty PanMoveWithCtrlProperty =
+            DependencyProperty.Register(nameof(PanMoveWithCtrl), typeof(AvailableWindows), typeof(FlyleafHost), new PropertyMetadata(AvailableWindows.Surface));
 
-        public bool PanMove
+        public AvailableWindows PanZoomWithCtrlWheel
         {
-            get { return (bool)GetValue(PanMoveProperty); }
-            set { SetValue(PanMoveProperty, value); }
+            get { return (AvailableWindows)GetValue(PanZoomWithCtrlWheelProperty); }
+            set { SetValue(PanZoomWithCtrlWheelProperty, value); }
         }
-        public static readonly DependencyProperty PanMoveProperty =
-            DependencyProperty.Register(nameof(PanMove), typeof(bool), typeof(FlyleafHost), new PropertyMetadata(true));
+        public static readonly DependencyProperty PanZoomWithCtrlWheelProperty =
+            DependencyProperty.Register(nameof(PanZoomWithCtrlWheel), typeof(AvailableWindows), typeof(FlyleafHost), new PropertyMetadata(AvailableWindows.Surface));
 
-        public AvailableWindows ResizeMode
+
+        public AttachedDragMoveOptions AttachedDragMove
         {
-            get { return (AvailableWindows)GetValue(ResizeModeProperty); }
-            set { SetValue(ResizeModeProperty, value); }
+            get { return (AttachedDragMoveOptions)GetValue(AttachedDragMoveProperty); }
+            set { SetValue(AttachedDragMoveProperty, value); }
         }
-        public static readonly DependencyProperty ResizeModeProperty =
-            DependencyProperty.Register(nameof(ResizeMode), typeof(AvailableWindows), typeof(FlyleafHost), new PropertyMetadata(AvailableWindows.Both));
+        public static readonly DependencyProperty AttachedDragMoveProperty =
+            DependencyProperty.Register(nameof(AttachedDragMove), typeof(AttachedDragMoveOptions), typeof(FlyleafHost), new PropertyMetadata(AttachedDragMoveOptions.Surface));
 
-        public bool ResizeOnAttach
+        public AvailableWindows DetachedDragMove
         {
-            get { return (bool)GetValue(ResizeOnAttachProperty); }
-            set { SetValue(ResizeOnAttachProperty, value); }
+            get { return (AvailableWindows)GetValue(DetachedDragMoveProperty); }
+            set { SetValue(DetachedDragMoveProperty, value); }
         }
-        public static readonly DependencyProperty ResizeOnAttachProperty =
-            DependencyProperty.Register(nameof(ResizeOnAttach), typeof(bool), typeof(FlyleafHost), new PropertyMetadata(false));
+        public static readonly DependencyProperty DetachedDragMoveProperty =
+            DependencyProperty.Register(nameof(DetachedDragMove), typeof(AvailableWindows), typeof(FlyleafHost), new PropertyMetadata(AvailableWindows.Surface));
+
 
-        public bool ResizeOnDetach
+        public AvailableWindows AttachedResize
         {
-            get { return (bool)GetValue(ResizeOnDetachProperty); }
-            set { SetValue(ResizeOnDetachProperty, value); }
+            get { return (AvailableWindows)GetValue(AttachedResizeProperty); }
+            set { SetValue(AttachedResizeProperty, value); }
         }
-        public static readonly DependencyProperty ResizeOnDetachProperty =
-            DependencyProperty.Register(nameof(ResizeOnDetach), typeof(bool), typeof(FlyleafHost), new PropertyMetadata(true));
+        public static readonly DependencyProperty AttachedResizeProperty =
+            DependencyProperty.Register(nameof(AttachedResize), typeof(AvailableWindows), typeof(FlyleafHost), new PropertyMetadata(AvailableWindows.Surface));
 
-        public bool ToggleFullScreenOnDoubleClick
+        public AvailableWindows DetachedResize
         {
-            get { return (bool)GetValue(ToggleFullScreenOnDoubleClickProperty); }
-            set { SetValue(ToggleFullScreenOnDoubleClickProperty, value); }
+            get { return (AvailableWindows)GetValue(DetachedResizeProperty); }
+            set { SetValue(DetachedResizeProperty, value); }
         }
-        public static readonly DependencyProperty ToggleFullScreenOnDoubleClickProperty =
-            DependencyProperty.Register(nameof(ToggleFullScreenOnDoubleClick), typeof(bool), typeof(FlyleafHost), new PropertyMetadata(true));
+        public static readonly DependencyProperty DetachedResizeProperty =
+            DependencyProperty.Register(nameof(DetachedResize), typeof(AvailableWindows), typeof(FlyleafHost), new PropertyMetadata(AvailableWindows.Surface));
+
+        public bool KeepRatioOnResize
+        {
+            get { return (bool)GetValue(KeepRatioOnResizeProperty); }
+            set { SetValue(KeepRatioOnResizeProperty, value); }
+        }
+        public static readonly DependencyProperty KeepRatioOnResizeProperty =
+            DependencyProperty.Register(nameof(KeepRatioOnResize), typeof(bool), typeof(FlyleafHost), new PropertyMetadata(false, new PropertyChangedCallback(OnKeepRatioOnResizeChanged)));
+
+        public float CurResizeRatio
+        {
+            get { return (float)GetValue(CurResizeRatioProperty); }
+            private set { SetValue(CurResizeRatioProperty, value); }
+        }
+        public static readonly DependencyProperty CurResizeRatioProperty =
+            DependencyProperty.Register(nameof(CurResizeRatio), typeof(float), typeof(FlyleafHost), new PropertyMetadata((float)0, new PropertyChangedCallback(OnCurResizeRatioChanged)));
+
+        public int ResizeSensitivity
+        {
+            get { return (int)GetValue(ResizeSensitivityProperty); }
+            set { SetValue(ResizeSensitivityProperty, value); }
+        }
+        public static readonly DependencyProperty ResizeSensitivityProperty =
+            DependencyProperty.Register(nameof(ResizeSensitivity), typeof(int), typeof(FlyleafHost), new PropertyMetadata(6));
+
+
+        public DetachedPositionOptions DetachedPosition
+        {
+            get { return (DetachedPositionOptions)GetValue(DetachedPositionProperty); }
+            set { SetValue(DetachedPositionProperty, value); }
+        }
+        public static readonly DependencyProperty DetachedPositionProperty =
+            DependencyProperty.Register(nameof(DetachedPosition), typeof(DetachedPositionOptions), typeof(FlyleafHost), new PropertyMetadata(DetachedPositionOptions.BottomRight));
+
+        public Thickness DetachedPositionMargin
+        {
+            get { return (Thickness)GetValue(DetachedPositionMarginProperty); }
+            set { SetValue(DetachedPositionMarginProperty, value); }
+        }
+        public static readonly DependencyProperty DetachedPositionMarginProperty =
+            DependencyProperty.Register(nameof(DetachedPositionMargin), typeof(Thickness), typeof(FlyleafHost), new PropertyMetadata(new Thickness(0, 0, 40, 40)));
+
+        public Point DetachedFixedPosition
+        {
+            get { return (Point)GetValue(DetachedFixedPositionProperty); }
+            set { SetValue(DetachedFixedPositionProperty, value); }
+        }
+        public static readonly DependencyProperty DetachedFixedPositionProperty =
+            DependencyProperty.Register(nameof(DetachedFixedPosition), typeof(Point), typeof(FlyleafHost), new PropertyMetadata(new Point()));
+
+        public Size DetachedFixedSize
+        {
+            get { return (Size)GetValue(DetachedFixedSizeProperty); }
+            set { SetValue(DetachedFixedSizeProperty, value); }
+        }
+        public static readonly DependencyProperty DetachedFixedSizeProperty =
+            DependencyProperty.Register(nameof(DetachedFixedSize), typeof(Size), typeof(FlyleafHost), new PropertyMetadata(new Size(300, 200)));
+
+        public bool DetachedRememberPosition
+        {
+            get { return (bool)GetValue(DetachedRememberPositionProperty); }
+            set { SetValue(DetachedRememberPositionProperty, value); }
+        }
+        public static readonly DependencyProperty DetachedRememberPositionProperty =
+            DependencyProperty.Register(nameof(DetachedRememberPosition), typeof(bool), typeof(FlyleafHost), new PropertyMetadata(true));
+
+        public bool DetachedRememberSize
+        {
+            get { return (bool)GetValue(DetachedRememberSizeProperty); }
+            set { SetValue(DetachedRememberSizeProperty, value); }
+        }
+        public static readonly DependencyProperty DetachedRememberSizeProperty =
+            DependencyProperty.Register(nameof(DetachedRememberSize), typeof(bool), typeof(FlyleafHost), new PropertyMetadata(true));
 
-        public Rect DetachedRect
+        public bool DetachedTopMost
         {
-            get { return (Rect)GetValue(DetachedRectProperty); }
-            set { SetValue(DetachedRectProperty, value); }
+            get { return (bool)GetValue(DetachedTopMostProperty); }
+            set { SetValue(DetachedTopMostProperty, value); }
         }
-        public static readonly DependencyProperty DetachedRectProperty =
-            DependencyProperty.Register(nameof(DetachedRect), typeof(Rect), typeof(FlyleafHost), new PropertyMetadata(Rect.Empty));
+        public static readonly DependencyProperty DetachedTopMostProperty =
+            DependencyProperty.Register(nameof(DetachedTopMost), typeof(bool), typeof(FlyleafHost), new PropertyMetadata(false, new PropertyChangedCallback(OnDetachedTopMostChanged)));
 
-        public AvailableWindows KeyBindingsMode
+        public AvailableWindows KeyBindings
         {
-            get { return (AvailableWindows)GetValue(KeyBindingsModeProperty); }
-            set { SetValue(KeyBindingsModeProperty, value); }
+            get { return (AvailableWindows)GetValue(KeyBindingsProperty); }
+            set { SetValue(KeyBindingsProperty, value); }
         }
-        public static readonly DependencyProperty KeyBindingsModeProperty =
-            DependencyProperty.Register(nameof(KeyBindingsMode), typeof(AvailableWindows), typeof(FlyleafHost), new PropertyMetadata(AvailableWindows.Surface));
+        public static readonly DependencyProperty KeyBindingsProperty =
+            DependencyProperty.Register(nameof(KeyBindings), typeof(AvailableWindows), typeof(FlyleafHost), new PropertyMetadata(AvailableWindows.Surface));
+
+
+        public int ActivityTimeout
+        {
+            get { return (int)GetValue(ActivityTimeoutProperty); }
+            set { SetValue(ActivityTimeoutProperty, value); }
+        }
+        public static readonly DependencyProperty ActivityTimeoutProperty =
+            DependencyProperty.Register(nameof(ActivityTimeout), typeof(int), typeof(FlyleafHost), new PropertyMetadata(0, new PropertyChangedCallback(OnActivityTimeoutChanged)));
+
 
         public bool IsAttached
         {
@@ -205,7 +308,7 @@ public bool IsFullScreen
             set { SetValue(IsFullScreenProperty, value); }
         }
         public static readonly DependencyProperty IsFullScreenProperty =
-            DependencyProperty.Register(nameof(IsFullScreen), typeof(bool), typeof(FlyleafHost), new PropertyMetadata(false, new PropertyChangedCallback(OnFullScreenChanged)));
+            DependencyProperty.Register(nameof(IsFullScreen), typeof(bool), typeof(FlyleafHost), new PropertyMetadata(false, new PropertyChangedCallback(OnIsFullScreenChanged)));
 
         public bool IsResizing
         {
@@ -215,29 +318,30 @@ public bool IsResizing
         public static readonly DependencyProperty IsResizingProperty =
             DependencyProperty.Register(nameof(IsResizing), typeof(bool), typeof(FlyleafHost), new PropertyMetadata(false));
 
-        public bool RememberLastDetachedRect
+        public bool IsStandAlone
         {
-            get { return (bool)GetValue(RememberLastDetachedRectProperty); }
-            set { SetValue(RememberLastDetachedRectProperty, value); }
+            get { return (bool)GetValue(IsStandAloneProperty); }
+            private set { SetValue(IsStandAloneProperty, value); }
         }
-        public static readonly DependencyProperty RememberLastDetachedRectProperty =
-            DependencyProperty.Register(nameof(RememberLastDetachedRect), typeof(bool), typeof(FlyleafHost), new PropertyMetadata(true));
+        public static readonly DependencyProperty IsStandAloneProperty =
+            DependencyProperty.Register(nameof(IsStandAlone), typeof(bool), typeof(FlyleafHost), new PropertyMetadata(false));
 
-        public int ResizeSensitivity
+        public bool IsSwapping
         {
-            get { return (int)GetValue(ResizeSensitivityProperty); }
-            set { SetValue(ResizeSensitivityProperty, value); }
+            get { return (bool)GetValue(IsSwappingProperty); }
+            private set { SetValue(IsSwappingProperty, value); }
         }
-        public static readonly DependencyProperty ResizeSensitivityProperty =
-            DependencyProperty.Register(nameof(ResizeSensitivity), typeof(int), typeof(FlyleafHost), new PropertyMetadata(6));
+        public static readonly DependencyProperty IsSwappingProperty =
+            DependencyProperty.Register(nameof(IsSwapping), typeof(bool), typeof(FlyleafHost), new PropertyMetadata(false));
 
-        public bool TopMost
+
+        public FrameworkElement MarginTarget
         {
-            get { return (bool)GetValue(TopMostProperty); }
-            set { SetValue(TopMostProperty, value); }
+            get { return (FrameworkElement)GetValue(MarginTargetProperty); }
+            set { SetValue(MarginTargetProperty, value); }
         }
-        public static readonly DependencyProperty TopMostProperty =
-            DependencyProperty.Register(nameof(TopMost), typeof(bool), typeof(FlyleafHost), new PropertyMetadata(true));
+        public static readonly DependencyProperty MarginTargetProperty =
+            DependencyProperty.Register(nameof(MarginTarget), typeof(FrameworkElement), typeof(FlyleafHost), new PropertyMetadata(null));
 
         public object HostDataContext
         {
@@ -273,6 +377,44 @@ public Window Overlay
         #endregion
 
         #region Events
+        private static void OnDetachedTopMostChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            FlyleafHost host = d as FlyleafHost;
+            host.Surface.Topmost = !host.IsAttached && host.DetachedTopMost;
+        }
+        private static void DropChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            FlyleafHost host = d as FlyleafHost;
+            host.Surface.AllowDrop =
+                host.OpenOnDrop == AvailableWindows.Surface || host.OpenOnDrop == AvailableWindows.Both ||
+                host.SwapOnDrop == AvailableWindows.Surface || host.SwapOnDrop == AvailableWindows.Both;
+
+            if (host.Overlay == null)
+                return;
+
+            host.Overlay.AllowDrop =
+                host.OpenOnDrop == AvailableWindows.Overlay || host.OpenOnDrop == AvailableWindows.Both ||
+                host.SwapOnDrop == AvailableWindows.Overlay || host.SwapOnDrop == AvailableWindows.Both;
+        }
+        private static void OnCurResizeRatioChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            FlyleafHost host = d as FlyleafHost;
+            if (host.KeepRatioOnResize)
+            {
+                if (host.IsAttached)
+                    host.Height = host.Width / host.CurResizeRatio;
+                else
+                    host.Surface.Height = host.Surface.Width / host.CurResizeRatio;
+            }
+        }
+        private static void OnKeepRatioOnResizeChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        {
+            FlyleafHost host = d as FlyleafHost;
+            if (host.KeepRatioOnResize)
+                host.CurResizeRatio = host.Player != null && host.Player.Video.AspectRatio.Value > 0 ? host.Player.Video.AspectRatio.Value : (float)(16.0/9.0);
+            else
+                host.CurResizeRatio = 0;
+        }
         private static void OnPlayerChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
         {
             if (isDesginMode)
@@ -281,7 +423,7 @@ private static void OnPlayerChanged(DependencyObject d, DependencyPropertyChange
             FlyleafHost host = d as FlyleafHost;
             host.SetPlayer((Player)e.OldValue);
         }
-        private static void OnFullScreenChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+        private static void OnIsFullScreenChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
         {
             if (isDesginMode)
                 return;
@@ -299,7 +441,7 @@ private static void OnIsAttachedChanged(DependencyObject d, DependencyPropertyCh
 
             FlyleafHost host = d as FlyleafHost;
 
-            if (host.isStandAlone)
+            if (host.IsStandAlone)
             {
                 host.IsAttached = false;
                 return;
@@ -398,13 +540,6 @@ protected override void OnContentChanged(object oldContent, object newContent) /
 
             base.OnContentChanged(oldContent, DetachedContent);
         }
-        protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
-        {
-            base.OnPropertyChanged(e);
-
-            if (e.Property.Name == nameof(AllowDrop) && Surface != null)
-                Surface.AllowDrop = AllowDrop;
-        }
         public override void OnApplyTemplate()
         {
             base.OnApplyTemplate();
@@ -553,14 +688,24 @@ private void Owner_LocationChanged(object sender, EventArgs e)
             if (IsAttached)
                 SetWindowPos(SurfaceHandle, IntPtr.Zero, (int)(pos.X * DpiX), (int)(pos.Y * DpiY), 0, 0, (UInt32)(SetWindowPosFlags.SWP_NOZORDER | (SetWindowPosFlags.SWP_NOSIZE | SetWindowPosFlags.SWP_NOACTIVATE)));
         }
+        private void Player_Video_PropertyChanged(object sender, PropertyChangedEventArgs e)
+        {
+            if (KeepRatioOnResize && e.PropertyName == nameof(Player.Video.AspectRatio) && Player.Video.AspectRatio.Value > 0)
+                CurResizeRatio = Player.Video.AspectRatio.Value;
+        }
+        #endregion
+
+        #region Events Surface / Overlay
+        private void Surface_KeyDown(object sender, KeyEventArgs e) { if (KeyBindings == AvailableWindows.Surface || KeyBindings == AvailableWindows.Both) e.Handled = Player.KeyDown(Player, e); }
+        private void Overlay_KeyDown(object sender, KeyEventArgs e) { if (KeyBindings == AvailableWindows.Overlay || KeyBindings == AvailableWindows.Both) e.Handled = Player.KeyDown(Player, e); }
+
+        private void Surface_KeyUp(object sender, KeyEventArgs e) { if (KeyBindings == AvailableWindows.Surface || KeyBindings == AvailableWindows.Both) e.Handled = Player.KeyUp(Player, e); }
+        private void Overlay_KeyUp(object sender, KeyEventArgs e) { if (KeyBindings == AvailableWindows.Overlay || KeyBindings == AvailableWindows.Both) e.Handled = Player.KeyUp(Player, e); }
 
-        private void Surface_Closing(object sender, CancelEventArgs e) { isSurfaceClosing = true; Dispose(); }
-        private void Surface_KeyDown(object sender, KeyEventArgs e) { if (KeyBindingsMode == AvailableWindows.Surface || KeyBindingsMode == AvailableWindows.Both) e.Handled = Player.KeyDown(Player, e); }
-        private void Surface_KeyUp(object sender, KeyEventArgs e) { if (KeyBindingsMode == AvailableWindows.Surface || KeyBindingsMode == AvailableWindows.Both) e.Handled = Player.KeyUp(Player, e); }
         private void Surface_Drop(object sender, DragEventArgs e)
         {
-            IsSwaping = false;
-
+            IsSwapping = false;
+            Surface.ReleaseMouseCapture();
             FlyleafHostDropWrap hostWrap = (FlyleafHostDropWrap) e.Data.GetData(typeof(FlyleafHostDropWrap));
             
             // Swap FlyleafHosts
@@ -589,15 +734,61 @@ private void Surface_Drop(object sender, DragEventArgs e)
                     Player.OpenAsync(text);
             }
         }
+        private void Overlay_Drop(object sender, DragEventArgs e)
+        {
+            IsSwapping = false;
+            Overlay.ReleaseMouseCapture();
+            FlyleafHostDropWrap hostWrap = (FlyleafHostDropWrap) e.Data.GetData(typeof(FlyleafHostDropWrap));
+            
+            // Swap FlyleafHosts
+            if (hostWrap != null)
+            {
+                (hostWrap.FlyleafHost.Player, Player) = (Player, hostWrap.FlyleafHost.Player);
+                Overlay.Activate();
+                return;
+            }
+
+            if (Player == null)
+                return;
+
+            // Player Open File
+            if (e.Data.GetDataPresent(DataFormats.FileDrop))
+            {
+                string filename = ((string[])e.Data.GetData(DataFormats.FileDrop, false))[0];
+                Player.OpenAsync(filename);
+            }
+
+            // Player Open Text
+            else if (e.Data.GetDataPresent(DataFormats.Text))
+            {
+                string text = e.Data.GetData(DataFormats.Text, false).ToString();
+                if (text.Length > 0)
+                    Player.OpenAsync(text);
+            }
+        }
         private void Surface_DragEnter(object sender, DragEventArgs e) { if (Player != null) e.Effects = DragDropEffects.All; }
+        private void Overlay_DragEnter(object sender, DragEventArgs e) { if (Player != null) e.Effects = DragDropEffects.All; }
+        private void Surface_StateChanged(object sender, EventArgs e)
+        {
+            if (Surface.WindowState == WindowState.Minimized)
+                preventFullScreenUpdate = true;
+            else
+            {
+                preventFullScreenUpdate = false;
+                RefreshNormalFullScreen();
+            }
+        }
+
         private void Surface_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
         {
-            // TBR: Capture / Release of mouse is wrong here
+            mouseLeftDownPoint = e.GetPosition(Surface);
 
-            if (Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift))
+            if ((SwapOnDrop == AvailableWindows.Surface || SwapOnDrop == AvailableWindows.Both) && 
+                (Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift)))
             {
-                DragDrop.DoDragDrop(this, new FlyleafHostDropWrap() { FlyleafHost = this }, DragDropEffects.Move);;
-                IsSwaping = true;
+                IsSwapping = true;
+                DragDrop.DoDragDrop(this, new FlyleafHostDropWrap() { FlyleafHost = this }, DragDropEffects.Move);
+                
                 return;
             }
 
@@ -608,8 +799,6 @@ private void Surface_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
             }
             else
             {
-                mouseLeftDownPoint = e.GetPosition(Surface);
-                mouseLeftDownDeactivated = false;
                 if (Player != null)
                 {
                     panPrevX = Player.PanXOffset;
@@ -619,47 +808,89 @@ private void Surface_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
 
             Surface.CaptureMouse();
         }
+        private void Overlay_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
+        {
+            mouseLeftDownPoint = e.GetPosition(Overlay);
+            
+            if ((SwapOnDrop == AvailableWindows.Overlay || SwapOnDrop == AvailableWindows.Both) && 
+                (Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift)))
+            {
+                IsSwapping = true;
+                DragDrop.DoDragDrop(this, new FlyleafHostDropWrap() { FlyleafHost = this }, DragDropEffects.Move);
+                
+                return;
+            }
+
+            if (ResizingSide != 0)
+            {
+                ReSetVisibleRect();
+                IsResizing = true;
+            }
+            else
+            {
+                if (Player != null)
+                {
+                    panPrevX = Player.PanXOffset;
+                    panPrevY = Player.PanYOffset;
+                }
+            }
+
+            Overlay.CaptureMouse();
+        }
+
         private void Surface_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
         {
             if (IsResizing)
             {
                 ResizingSide = 0;
                 Surface.Cursor = Cursors.Arrow;
-                //Overlay.Cursor = Cursors.Arrow;
                 IsResizing = false;
+                Host_LayoutUpdated(null, null); // When attached to restore the clipped rect
             }
             mouseLeftDownPoint.X = -1;
-            IsSwaping = false;
+            IsSwapping = false;
             Surface.ReleaseMouseCapture();
         }
+        private void Overlay_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
+        {
+            if (IsResizing)
+            {
+                ResizingSide = 0;
+                Overlay.Cursor = Cursors.Arrow;
+                IsResizing = false;
+                Host_LayoutUpdated(null, null); // When attached to restore the clipped rect
+            }
+            mouseLeftDownPoint.X = -1;
+            IsSwapping = false;
+            Overlay.ReleaseMouseCapture();
+        }
+
         private void Surface_MouseMove(object sender, MouseEventArgs e)
         {
             Point cur = e.GetPosition(Surface);
-
+             
             if (Player != null && ActivityTimeout > 0 && cur != lastOverlayPosition)
                 Player.Activity.RefreshFullActive();
-
+            
             // Resize Sides (CanResize + !MouseDown + !FullScreen)
             if (e.MouseDevice.LeftButton != MouseButtonState.Pressed)
             {
                 if ( Surface.WindowState != WindowState.Maximized && 
-                    (ResizeMode == AvailableWindows.Surface || ResizeMode == AvailableWindows.Both) &&
-                    (IsAttached && ResizeOnAttach) ||
-                    (!IsAttached && ResizeOnDetach) )
+                    ((IsAttached && (AttachedResize == AvailableWindows.Surface || AttachedResize == AvailableWindows.Both)) ||
+                    (!IsAttached && (DetachedResize == AvailableWindows.Surface || DetachedResize == AvailableWindows.Both))))
                 {
                     ResizingSide = ResizeSides(Surface, cur, ResizeSensitivity);
                 }
-                        
             }
-            else if (IsSwaping)
+            else if (IsSwapping)
                 return;
 
             // Resize (MouseDown + ResizeSide != 0)
-            else if (IsResizing) //AllowResize &&  && !IsAttached)
+            else if (IsResizing)
             {
                 Point x1 = new Point(Surface.Left, Surface.Top);
 
-                Resize(Surface, SurfaceHandle, cur, ResizingSide);
+                Resize(Surface, SurfaceHandle, cur, ResizingSide, CurResizeRatio);
 
                 if (IsAttached)
                 {
@@ -676,18 +907,20 @@ private void Surface_MouseMove(object sender, MouseEventArgs e)
                 return;
 
             // Player's Pan Move (Ctrl + Drag Move)
-            else if (PanMove && Player != null && (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl)))
+            else if (Player != null && 
+                (PanMoveWithCtrl == AvailableWindows.Surface || PanMoveWithCtrl == AvailableWindows.Both) &&
+                (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl)))
             {
                 Player.PanXOffset = panPrevX + (int) (cur.X - mouseLeftDownPoint.X);
                 Player.PanYOffset = panPrevY + (int) (cur.Y - mouseLeftDownPoint.Y);
             }
 
             // Drag Move Self (Detached) / Self (Attached) / Owner (Attached)
-            else if (!mouseLeftDownDeactivated && Surface.WindowState != WindowState.Maximized)
+            else if (Surface.IsMouseCaptured && Surface.WindowState != WindowState.Maximized)
             {
                 if (IsAttached)
                 {
-                    if (DragMoveOnAttach == AttachedDragMoveMode.Owner)
+                    if (AttachedDragMove == AttachedDragMoveOptions.SurfaceOwner || AttachedDragMove == AttachedDragMoveOptions.BothOwner)
                     {
                         if (Owner != null)
                         {
@@ -695,14 +928,14 @@ private void Surface_MouseMove(object sender, MouseEventArgs e)
                             Owner.Top += cur.Y - mouseLeftDownPoint.Y;
                         }
                     }
-                    else if (DragMoveOnAttach == AttachedDragMoveMode.Self)
+                    else if (AttachedDragMove == AttachedDragMoveOptions.Surface || AttachedDragMove == AttachedDragMoveOptions.Both)
                     {
                         // TBR: Bug with right click (popup menu) and then left click drag
                         MarginTarget.Margin = new Thickness(MarginTarget.Margin.Left + cur.X - mouseLeftDownPoint.X, MarginTarget.Margin.Top + cur.Y - mouseLeftDownPoint.Y, MarginTarget.Margin.Right, MarginTarget.Margin.Bottom);
                     }
                 } else
                 {
-                    if (DragMoveOnDetach)
+                    if (DetachedDragMove == AvailableWindows.Surface || DetachedDragMove == AvailableWindows.Both)
                     {
                         Surface.Left  += cur.X - mouseLeftDownPoint.X;
                         Surface.Top   += cur.Y - mouseLeftDownPoint.Y;
@@ -710,85 +943,117 @@ private void Surface_MouseMove(object sender, MouseEventArgs e)
                 }
             }
         }
-        private void Surface_MouseWheel(object sender, MouseWheelEventArgs e)
-        {
-            if (PanMove && Player != null && e.Delta != 0 && (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl)))
-            {
-                Player.Zoom += e.Delta > 0 ? Player.Config.Player.ZoomOffset : -Player.Config.Player.ZoomOffset;
-            }
-            //else if (IsAttached) // TBR ScrollViewer
-            //{
-            //    RaiseEvent(e);
-            //}
-        }
-        private void Surface_MouseDoubleClick(object sender, MouseButtonEventArgs e) { if (!ToggleFullScreenOnDoubleClick) return; IsFullScreen = !IsFullScreen; e.Handled = true; }
-        private void Surface_Deactivated(object sender, EventArgs e) { mouseLeftDownDeactivated = true; Surface.Cursor = Cursors.Arrow; ResizingSide = 0; }
-        private void Surface_StateChanged(object sender, EventArgs e)
-        {
-            if (Surface.WindowState == WindowState.Minimized)
-                preventFullScreenUpdate = true;
-            else
-            {
-                preventFullScreenUpdate = false;
-                RefreshNormalFullScreen();
-            }
-        }
-
-        private void Overlay_Closing(object sender, CancelEventArgs e) { if (isSurfaceClosing) return; e.Cancel = true; Surface.Close(); }
-        private void Overlay_KeyDown(object sender, KeyEventArgs e) { if (KeyBindingsMode == AvailableWindows.Overlay || KeyBindingsMode == AvailableWindows.Both) e.Handled = Player.KeyDown(Player, e); }
-        private void Overlay_KeyUp(object sender, KeyEventArgs e) { if (KeyBindingsMode == AvailableWindows.Overlay || KeyBindingsMode == AvailableWindows.Both) e.Handled = Player.KeyUp(Player, e); }
-        private void Overlay_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
-        {
-            if (ResizingSideOverlay != 0)
-            {
-                ReSetVisibleRect();
-                IsResizing = true;
-                Overlay.CaptureMouse();
-            }
-        }
-        private void Overlay_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
-        {
-            if (IsResizing)
-            {
-                ResizingSideOverlay = 0;
-                //Surface.Cursor = Cursors.Arrow;
-                Overlay.Cursor = Cursors.Arrow;
-                IsResizing = false;
-                Overlay.ReleaseMouseCapture();
-            }
-        }
         private void Overlay_MouseMove(object sender, MouseEventArgs e)
         {
             Point cur = e.GetPosition(Overlay);
-            lastOverlayPosition = cur;
-
+             
+            if (Player != null && ActivityTimeout > 0 && cur != lastOverlayPosition)
+                Player.Activity.RefreshFullActive();
+            
+            // Resize Sides (CanResize + !MouseDown + !FullScreen)
             if (e.MouseDevice.LeftButton != MouseButtonState.Pressed)
             {
-                if ( Overlay.WindowState != WindowState.Maximized &&
-                    (ResizeMode == AvailableWindows.Overlay || ResizeMode == AvailableWindows.Both) &&
-                    (IsAttached && ResizeOnAttach) ||
-                    (!IsAttached && ResizeOnDetach) )
+                if ( Overlay.WindowState != WindowState.Maximized && 
+                    ((IsAttached && (AttachedResize == AvailableWindows.Overlay || AttachedResize == AvailableWindows.Both)) ||
+                    (!IsAttached && (DetachedResize == AvailableWindows.Overlay || DetachedResize == AvailableWindows.Both))))
                 {
-                    ResizingSideOverlay = ResizeSides(Overlay, cur, ResizeSensitivity);
+                    ResizingSide = ResizeSides(Overlay, cur, ResizeSensitivity);
                 }
             }
+            else if (IsSwapping)
+                return;
 
             // Resize (MouseDown + ResizeSide != 0)
-            else if (IsResizing) //AllowResize &&  && !IsAttached)
+            else if (IsResizing)
             {
                 Point x1 = new Point(Overlay.Left, Overlay.Top);
-                Resize(Overlay, OverlayHandle, cur, ResizingSideOverlay);
+
+                Resize(Overlay, OverlayHandle, cur, ResizingSide, CurResizeRatio);
+
                 if (IsAttached)
                 {
                     Point x2 = new Point(Overlay.Left, Overlay.Top);
-
+                    
                     MarginTarget.Margin = new Thickness(MarginTarget.Margin.Left + x2.X - x1.X, MarginTarget.Margin.Top + x2.Y - x1.Y, MarginTarget.Margin.Right, MarginTarget.Margin.Bottom);
                     Width = Overlay.Width;
                     Height = Overlay.Height;
                 }
             }
+
+            // Bug? happens on double click
+            else if (mouseLeftDownPoint.X == -1)
+                return;
+
+            // Player's Pan Move (Ctrl + Drag Move)
+            else if (Player != null && 
+                (PanMoveWithCtrl == AvailableWindows.Overlay || PanMoveWithCtrl == AvailableWindows.Both) &&
+                (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl)))
+            {
+                Player.PanXOffset = panPrevX + (int) (cur.X - mouseLeftDownPoint.X);
+                Player.PanYOffset = panPrevY + (int) (cur.Y - mouseLeftDownPoint.Y);
+            }
+
+            // Drag Move Self (Detached) / Self (Attached) / Owner (Attached)
+            else if (Overlay.IsMouseCaptured && Overlay.WindowState != WindowState.Maximized)
+            {
+                if (IsAttached)
+                {
+                    if (AttachedDragMove == AttachedDragMoveOptions.OverlayOwner || AttachedDragMove == AttachedDragMoveOptions.BothOwner)
+                    {
+                        if (Owner != null)
+                        {
+                            Owner.Left += cur.X - mouseLeftDownPoint.X;
+                            Owner.Top += cur.Y - mouseLeftDownPoint.Y;
+                        }
+                    }
+                    else if (AttachedDragMove == AttachedDragMoveOptions.Overlay || AttachedDragMove == AttachedDragMoveOptions.Both)
+                    {
+                        // TBR: Bug with right click (popup menu) and then left click drag
+                        MarginTarget.Margin = new Thickness(MarginTarget.Margin.Left + cur.X - mouseLeftDownPoint.X, MarginTarget.Margin.Top + cur.Y - mouseLeftDownPoint.Y, MarginTarget.Margin.Right, MarginTarget.Margin.Bottom);
+                    }
+                } else
+                {
+                    if (DetachedDragMove == AvailableWindows.Overlay || DetachedDragMove == AvailableWindows.Both)
+                    {
+                        Overlay.Left  += cur.X - mouseLeftDownPoint.X;
+                        Overlay.Top   += cur.Y - mouseLeftDownPoint.Y;
+                    }
+                }
+            }
+        }
+
+        private void Surface_MouseLeave(object sender, MouseEventArgs e) { ResizingSide = 0; Surface.Cursor = Cursors.Arrow; }
+        private void Overlay_MouseLeave(object sender, MouseEventArgs e) { ResizingSide = 0; Overlay.Cursor = Cursors.Arrow; }
+
+        private void Surface_MouseDoubleClick(object sender, MouseButtonEventArgs e) { if (ToggleFullScreenOnDoubleClick == AvailableWindows.Surface || ToggleFullScreenOnDoubleClick == AvailableWindows.Both) { IsFullScreen = !IsFullScreen; e.Handled = true; } }
+        private void Overlay_MouseDoubleClick(object sender, MouseButtonEventArgs e) { if (ToggleFullScreenOnDoubleClick == AvailableWindows.Overlay || ToggleFullScreenOnDoubleClick == AvailableWindows.Both) { IsFullScreen = !IsFullScreen; e.Handled = true; } }
+
+        private void Surface_MouseWheel(object sender, MouseWheelEventArgs e)
+        {
+            if (Player != null && e.Delta != 0 && 
+                (PanZoomWithCtrlWheel == AvailableWindows.Surface || PanZoomWithCtrlWheel == AvailableWindows.Both) &&
+                (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl)))
+            {
+                Player.Zoom += e.Delta > 0 ? Player.Config.Player.ZoomOffset : -Player.Config.Player.ZoomOffset;
+            }
+            //else if (IsAttached) // TBR ScrollViewer
+            //{
+            //    RaiseEvent(e);
+            //}
+        }
+        private void Overlay_MouseWheel(object sender, MouseWheelEventArgs e)
+        {
+            if (Player != null && e.Delta != 0 && 
+                (PanZoomWithCtrlWheel == AvailableWindows.Overlay || PanZoomWithCtrlWheel == AvailableWindows.Both) &&
+                (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl)))
+            {
+                Player.Zoom += e.Delta > 0 ? Player.Config.Player.ZoomOffset : -Player.Config.Player.ZoomOffset;
+            }
         }
 
+        private void Surface_Closing(object sender, CancelEventArgs e) { isSurfaceClosing = true; Dispose(); }
+        private void Overlay_Closing(object sender, CancelEventArgs e) { if (isSurfaceClosing) return; e.Cancel = true; Surface.Close(); }
+
         private void Overlay_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e)
         { // Stand Alone Only (Main control has the overlay)
             if (Overlay.IsVisible)
@@ -806,18 +1071,22 @@ private void Overlay_Loaded(object sender, RoutedEventArgs e)
                 Surface.Show();
         }
 
-        public static void Resize(Window Window, IntPtr WindowHandle, Point p, int resizingSide)
+        public static void Resize(Window Window, IntPtr WindowHandle, Point p, int resizingSide, double ratio = 0.0)
         {
             double WindowWidth = Window.ActualWidth, WindowHeight = Window.ActualHeight, WindowLeft = Window.Left, WindowTop = Window.Top;
 
             if (resizingSide == 2 || resizingSide == 3 || resizingSide == 6)
             {
                 p.X += 5;
+
                 if (p.X > Window.MinWidth)
-                    WindowWidth = p.X;
+                {
+                    WindowWidth = p.X < Window.MaxWidth ? p.X : Window.MaxWidth;
+                }
+                else
+                    WindowWidth = Window.MinWidth;
             }
-
-            if (resizingSide == 1 || resizingSide == 4 || resizingSide == 5)
+            else if (resizingSide == 1 || resizingSide == 4 || resizingSide == 5)
             {
                 p.X -= 5;
                 double temp = Window.ActualWidth - p.X;
@@ -831,11 +1100,15 @@ public static void Resize(Window Window, IntPtr WindowHandle, Point p, int resiz
             if (resizingSide == 2 || resizingSide == 4 || resizingSide == 8)
             {
                 p.Y += 5;
+
                 if (p.Y > Window.MinHeight)
-                    WindowHeight = p.Y;
+                {
+                    WindowHeight = p.Y < Window.MaxHeight ? p.Y : Window.MaxHeight;
+                }
+                else
+                    p.Y = Window.MinHeight;
             }
-
-            if (resizingSide == 1 || resizingSide == 3 || resizingSide == 7)
+            else if (resizingSide == 1 || resizingSide == 3 || resizingSide == 7)
             {
                 p.Y -= 5;
                 double temp = Window.ActualHeight - p.Y;
@@ -844,9 +1117,19 @@ public static void Resize(Window Window, IntPtr WindowHandle, Point p, int resiz
                     WindowHeight = temp;
                     WindowTop += p.Y;
                 }
+                else
+                {
+                    WindowHeight = temp > Window.MinHeight ? Window.MaxHeight : Window.MinHeight;
+                }
             }
 
-            SetWindowPos(WindowHandle, IntPtr.Zero, (int)(WindowLeft * DpiX), (int)(WindowTop * DpiY), (int)(WindowWidth * DpiX), (int)(WindowHeight * DpiY), (UInt32)(SetWindowPosFlags.SWP_NOZORDER | SetWindowPosFlags.SWP_NOACTIVATE));
+            // TBR: should also change position on some cases
+            if (ratio == 0)
+                SetWindowPos(WindowHandle, IntPtr.Zero, (int)(WindowLeft * DpiX), (int)(WindowTop * DpiY), (int)(WindowWidth * DpiX), (int)(WindowHeight * DpiY), (UInt32)(SetWindowPosFlags.SWP_NOZORDER | SetWindowPosFlags.SWP_NOACTIVATE));
+            else if (resizingSide == 7 || resizingSide == 8)
+                SetWindowPos(WindowHandle, IntPtr.Zero, (int)(WindowLeft * DpiX), (int)(WindowTop * DpiY), (int)((WindowHeight * ratio) * DpiX), (int)(WindowHeight * DpiY), (UInt32)(SetWindowPosFlags.SWP_NOZORDER | SetWindowPosFlags.SWP_NOACTIVATE));
+            else
+                SetWindowPos(WindowHandle, IntPtr.Zero, (int)(WindowLeft * DpiX), (int)(WindowTop * DpiY), (int)(WindowWidth * DpiX), (int)((WindowWidth / ratio) * DpiY), (UInt32)(SetWindowPosFlags.SWP_NOZORDER | SetWindowPosFlags.SWP_NOACTIVATE));
         }
         public static int ResizeSides(Window Window, Point p, int ResizeSensitivity)
         {
@@ -898,13 +1181,14 @@ public static int ResizeSides(Window Window, Point p, int ResizeSensitivity)
         }
         #endregion
 
+        #region Constructors
         static FlyleafHost()
         {
             DefaultStyleKeyProperty.OverrideMetadata(typeof(FlyleafHost), new FrameworkPropertyMetadata(typeof(FlyleafHost)));
-            AllowDropProperty.OverrideMetadata(typeof(FlyleafHost), new FrameworkPropertyMetadata(true));
         }
         public FlyleafHost()
         {
+            UniqueId = idGenerator++;
             isDesginMode = DesignerProperties.GetIsInDesignMode(this);
             //isDesginMode = true;
             if (isDesginMode)
@@ -927,7 +1211,7 @@ public FlyleafHost()
 
             MarginTarget = this;
 
-            Log = new LogHandler(("[#" + UniqueId + "]").PadRight(8, ' ') + $" [FlyleafHost   ] ");
+            Log = new LogHandler(("[#" + UniqueId + "]").PadRight(8, ' ') + $" [FlyleafHost NP] ");
             Loaded      += Host_Loaded; // Initialized event ??
             Unloaded    += Host_Unloaded;
             DataContextChanged 
@@ -937,109 +1221,17 @@ public FlyleafHost()
         }
         public FlyleafHost(Window standAloneOverlay)
         {
-            Log = new LogHandler(("[#" + UniqueId + "]").PadRight(8, ' ') + $" [FlyleafHost   ] ");
+            UniqueId = idGenerator++;
+            Log = new LogHandler(("[#" + UniqueId + "]").PadRight(8, ' ') + $" [FlyleafHost NP] ");
 
-            isStandAlone = true;
+            IsStandAlone = true;
             IsAttached = false;
             SetSurface();
             Overlay = standAloneOverlay;
         }
+        #endregion
 
-        public virtual void Attach()
-        {
-            rectDetachedLast = new Rect(Surface.Left, Surface.Top, Surface.Width, Surface.Height);
-
-            if (TopMost)
-                Surface.Topmost = false;
-
-            Surface.MinWidth = MinWidth;
-            Surface.MinHeight = MinHeight;
-                
-            Surface.Owner = Owner;
-
-            if (Surface.IsVisible)
-                Surface.Activate();
-
-            rectInitLast = rectIntersectLast = new Rect(1, 2, 3, 4);
-            Host_LayoutUpdated(null, null);
-        }
-        public virtual void Detach()
-        {
-            //if (AllowDetachedResize && MinWidth == 0)
-            //{
-            //    Surface.MinWidth = Math.Min(Surface.Width, 100);
-            //    Surface.MinHeight= Math.Min(Surface.Height, 100);
-            //}
-
-            if (RememberLastDetachedRect && rectDetachedLast != Rect.Empty)
-                SetRect(rectDetachedLast);
-            else
-            {
-                if (DetachedRect == Rect.Empty)
-                {
-                    var width = 350; var height = 200;
-                    DetachedRect = new Rect(SystemParameters.MaximizedPrimaryScreenWidth - width - 20, SystemParameters.MaximizedPrimaryScreenHeight - height - 20, width, height);
-                }
-
-                SetRect(DetachedRect);
-            }
-
-            ReSetVisibleRect();
-
-            if (TopMost)
-                Surface.Topmost = true;
-
-            Surface.Owner = null;
-
-            if (Surface.IsVisible)
-                Surface.Activate();
-        }
-
-        public void RefreshNormalFullScreen()
-        {
-            if (preventFullScreenUpdate)
-            {
-                preventFullScreenUpdate = false;
-                return;
-            }
-
-            if (IsFullScreen)
-            {
-                if (IsAttached)
-                    ReSetVisibleRect();
-
-                Surface.WindowState = WindowState.Maximized;
-            }
-            else
-            {
-                Surface.WindowState = WindowState.Normal;
-
-                if (IsAttached)
-                {
-                    rectInitLast = rectIntersectLast = Rect.Empty;
-                    Host_LayoutUpdated(null, null);
-                }
-            }
-        }
-
-        public void SetRect(Rect rect)
-        {
-            SetWindowPos(SurfaceHandle, IntPtr.Zero, (int)(rect.X * DpiX), (int)(rect.Y * DpiY), (int)(rect.Width * DpiX), (int)(rect.Height * DpiY), (UInt32)(SetWindowPosFlags.SWP_NOZORDER | SetWindowPosFlags.SWP_NOACTIVATE));
-        }
-        public void ReSetVisibleRect()
-        {
-            SetWindowRgn(SurfaceHandle, IntPtr.Zero, true);
-            if (OverlayHandle != IntPtr.Zero)
-                SetWindowRgn(OverlayHandle, IntPtr.Zero, true);
-        }
-        public void SetVisibleRect(Rect rect)
-        {
-            SetWindowRgn(SurfaceHandle, CreateRectRgn((int)(rect.X * DpiX), (int)(rect.Y * DpiY), (int)(rect.Right * DpiX), (int)(rect.Bottom * DpiY)), true);
-
-            if (OverlayHandle != IntPtr.Zero)
-                SetWindowRgn(OverlayHandle, CreateRectRgn((int)(rect.X * DpiX), (int)(rect.Y * DpiY), (int)(rect.Right * DpiX), (int)(rect.Bottom * DpiY)), true);
-        }
-
+        #region Methods
         public virtual void SetPlayer(Player oldPlayer)
         {
             // De-assign old Player's Handle/FlyleafHost
@@ -1047,6 +1239,8 @@ public virtual void SetPlayer(Player oldPlayer)
             {
                 Log.Debug($"De-assign Player #{oldPlayer.PlayerId}");
 
+                oldPlayer.Video.PropertyChanged -= Player_Video_PropertyChanged;
+
                 if (oldPlayer.renderer != null)
                     oldPlayer.renderer.SetControl(null);
                 
@@ -1058,11 +1252,7 @@ public virtual void SetPlayer(Player oldPlayer)
                 return;
 
             // Set UniqueId (First Player's Id)
-            if (UniqueId == -1)
-            {
-                UniqueId    = Player.PlayerId;
-                Log.Prefix  = ("[#" + UniqueId + "]").PadRight(8, ' ') + $" [FlyleafHost   ] ";
-            }
+            Log.Prefix  = ("[#" + UniqueId + "]").PadRight(8, ' ') + $" [FlyleafHost #{Player.PlayerId}] ";
 
             // De-assign new Player's Handle/FlyleafHost
             if (Player.WPFHost != null)
@@ -1078,16 +1268,19 @@ public virtual void SetPlayer(Player oldPlayer)
             Player.Activity.Timeout = ActivityTimeout;
             Player.IsFullScreen = IsFullScreen;
             Player.VideoDecoder.CreateRenderer(Surface);
+
+            Player.Video.PropertyChanged += Player_Video_PropertyChanged;
+            if (KeepRatioOnResize && Player.Video.AspectRatio.Value > 0)
+                CurResizeRatio = Player.Video.AspectRatio.Value;
         }
         public virtual void SetSurface()
         {
             Surface = new Window();
-            Surface.ShowInTaskbar = isStandAlone;
+            Surface.ShowInTaskbar = IsStandAlone;
             Surface.Background  = Brushes.Black;
             Surface.WindowStyle = WindowStyle.None;
-            Surface.ResizeMode  = System.Windows.ResizeMode.NoResize;
+            Surface.ResizeMode  = ResizeMode.NoResize;
             Surface.Width       = Surface.Height = 1; // Will be set on loaded
-            Surface.AllowDrop   = AllowDrop;
 
             SurfaceHandle       = new WindowInteropHelper(Surface).EnsureHandle();
 
@@ -1103,9 +1296,9 @@ public virtual void SetSurface()
                                 += Surface_MouseDoubleClick;
             Surface.DragEnter   += Surface_DragEnter;
             Surface.Drop        += Surface_Drop;
-            Surface.Deactivated += Surface_Deactivated;
             Surface.MouseWheel  += Surface_MouseWheel;
-            Surface.StateChanged += Surface_StateChanged;
+            Surface.StateChanged+= Surface_StateChanged;
+            Surface.MouseLeave  += Surface_MouseLeave;
         }
         public virtual void SetOverlay()
         {
@@ -1117,7 +1310,7 @@ public virtual void SetOverlay()
 
             Overlay.Background = Brushes.Transparent;
             Overlay.WindowStyle = WindowStyle.None;
-            Overlay.ResizeMode = System.Windows.ResizeMode.NoResize;
+            Overlay.ResizeMode = ResizeMode.NoResize;
             Overlay.AllowsTransparency = true;
 
             OverlayHandle = new WindowInteropHelper(Overlay).EnsureHandle();
@@ -1133,7 +1326,7 @@ public virtual void SetOverlay()
             Overlay.ShowInTaskbar = false;
             Surface.Topmost = wasTopmost;
 
-            if (isStandAlone)
+            if (IsStandAlone)
             {
                 Overlay.IsVisibleChanged 
                                 += Overlay_IsVisibleChanged;
@@ -1166,16 +1359,168 @@ public virtual void SetOverlay()
                                 += Overlay_MouseLeftButtonDown;
             Overlay.MouseLeftButtonUp
                                 += Overlay_MouseLeftButtonUp;
+            Overlay.MouseWheel  += Overlay_MouseWheel;
             Overlay.MouseMove   += Overlay_MouseMove;
+            Overlay.MouseLeave  += Overlay_MouseLeave;
+            Overlay.MouseDoubleClick
+                                += Overlay_MouseDoubleClick;
+            Overlay.Drop        += Overlay_Drop;
+            Overlay.DragEnter   += Overlay_DragEnter;
 
             // Owner will close the overlay
-            Overlay.KeyDown += (o, e)   => { if (e.Key == Key.System && e.SystemKey == Key.F4) Surface?.Focus(); };
+            Overlay.KeyDown += (o, e) => { if (e.Key == Key.System && e.SystemKey == Key.F4) Surface?.Focus(); };
+
+            Overlay.AllowDrop =
+                OpenOnDrop == AvailableWindows.Overlay || OpenOnDrop == AvailableWindows.Both ||
+                SwapOnDrop == AvailableWindows.Overlay || SwapOnDrop == AvailableWindows.Both;
 
             //??
             if (Surface.IsVisible)
                 Overlay.Visibility = Visibility.Visible;
         }
 
+        public virtual void Attach()
+        {
+            rectDetachedLast = new Rect(Surface.Left, Surface.Top, Surface.Width, Surface.Height);
+
+            if (DetachedTopMost)
+                Surface.Topmost = false;
+
+            Surface.MinWidth = MinWidth;
+            Surface.MinHeight = MinHeight;
+                
+            Surface.Owner = Owner;
+
+            if (Surface.IsVisible)
+                Surface.Activate();
+
+            rectInitLast = rectIntersectLast = rectRandom;
+            Host_LayoutUpdated(null, null);
+        }
+        public virtual void Detach()
+        {
+            // Calculate Size
+            Size newSize;
+            if (DetachedRememberSize && rectDetachedLast != Rect.Empty)
+                newSize = new Size(rectDetachedLast.Width, rectDetachedLast.Height);
+            else if (!DetachedFixedSize.IsEmpty)
+                newSize = DetachedFixedSize;
+            else
+                newSize = new Size(Surface.Width, Surface.Height);
+
+            // Calculate Position
+            Point newPos;
+            if (DetachedRememberPosition && rectDetachedLast != Rect.Empty)
+                newPos = new Point(rectDetachedLast.X, rectDetachedLast.Y);
+            else
+            {
+                switch (DetachedPosition)
+                {
+                    case DetachedPositionOptions.TopLeft:
+                        newPos = new Point(0, 0);
+                        break;
+                    case DetachedPositionOptions.TopCenter:
+                        newPos = new Point((SystemParameters.PrimaryScreenWidth / 2) - (newSize.Width / 2), 0);
+                        break;
+
+                    case DetachedPositionOptions.TopRight:
+                        newPos = new Point(SystemParameters.PrimaryScreenWidth - newSize.Width, 0);
+                        break;
+
+                    case DetachedPositionOptions.CenterLeft:
+                        newPos = new Point(0, (SystemParameters.PrimaryScreenHeight / 2) - (newSize.Height / 2));
+                        break;
+
+                    case DetachedPositionOptions.CenterCenter:
+                        newPos = new Point((SystemParameters.PrimaryScreenWidth / 2) - (newSize.Width / 2), (SystemParameters.PrimaryScreenHeight / 2) - (newSize.Height / 2));
+                        break;
+
+                    case DetachedPositionOptions.CenterRight:
+                        newPos = new Point(SystemParameters.PrimaryScreenWidth - newSize.Width, (SystemParameters.PrimaryScreenHeight / 2) - (newSize.Height / 2));
+                        break;
+
+                    case DetachedPositionOptions.BottomLeft:
+                        newPos = new Point(0, SystemParameters.PrimaryScreenHeight - newSize.Height);
+                        break;
+
+                    case DetachedPositionOptions.BottomCenter:
+                        newPos = new Point((SystemParameters.PrimaryScreenWidth / 2) - (newSize.Width / 2), SystemParameters.PrimaryScreenHeight - newSize.Height);
+                        break;
+
+                    case DetachedPositionOptions.BottomRight:
+                        newPos = new Point(SystemParameters.PrimaryScreenWidth - newSize.Width, SystemParameters.PrimaryScreenHeight - newSize.Height);
+                        break;
+
+                    case DetachedPositionOptions.Custom:
+                        newPos = DetachedFixedPosition;
+                        break;
+
+                    default:
+                        newPos = new Point(Surface.Left, Surface.Top);
+                        break;
+                }
+
+                newPos.X += (DetachedPositionMargin.Left - DetachedPositionMargin.Right);
+                newPos.Y += (DetachedPositionMargin.Top - DetachedPositionMargin.Bottom);
+            }
+            Rect final = new Rect(newPos.X, newPos.Y, newSize.Width, newSize.Height);
+
+            SetRect(final);
+            ReSetVisibleRect();
+
+            if (DetachedTopMost)
+                Surface.Topmost = true;
+
+            Surface.Owner = null;
+
+            if (Surface.IsVisible)
+                Surface.Activate();
+        }
+
+        public void RefreshNormalFullScreen()
+        {
+            if (preventFullScreenUpdate)
+            {
+                preventFullScreenUpdate = false;
+                return;
+            }
+
+            if (IsFullScreen)
+            {
+                if (IsAttached)
+                    ReSetVisibleRect();
+
+                Surface.WindowState = WindowState.Maximized;
+            }
+            else
+            {
+                Surface.WindowState = WindowState.Normal;
+
+                if (IsAttached)
+                {
+                    rectInitLast = rectIntersectLast = Rect.Empty;
+                    Host_LayoutUpdated(null, null);
+                }
+            }
+        }
+        public void SetRect(Rect rect)
+        {
+            SetWindowPos(SurfaceHandle, IntPtr.Zero, (int)(rect.X * DpiX), (int)(rect.Y * DpiY), (int)(rect.Width * DpiX), (int)(rect.Height * DpiY), (UInt32)(SetWindowPosFlags.SWP_NOZORDER | SetWindowPosFlags.SWP_NOACTIVATE));
+        }
+        public void ReSetVisibleRect()
+        {
+            SetWindowRgn(SurfaceHandle, IntPtr.Zero, true);
+            if (OverlayHandle != IntPtr.Zero)
+                SetWindowRgn(OverlayHandle, IntPtr.Zero, true);
+        }
+        public void SetVisibleRect(Rect rect)
+        {
+            SetWindowRgn(SurfaceHandle, CreateRectRgn((int)(rect.X * DpiX), (int)(rect.Y * DpiY), (int)(rect.Right * DpiX), (int)(rect.Bottom * DpiY)), true);
+
+            if (OverlayHandle != IntPtr.Zero)
+                SetWindowRgn(OverlayHandle, CreateRectRgn((int)(rect.X * DpiX), (int)(rect.Y * DpiY), (int)(rect.Right * DpiX), (int)(rect.Bottom * DpiY)), true);
+        }
+
         public void Dispose()
         {
             lock (this)
@@ -1188,12 +1533,13 @@ public void Dispose()
                 if (Surface != null)
                 {
                     Surface.MouseMove -= Surface_MouseMove;
-                    Surface.Deactivated -= Surface_Deactivated;
+                    Surface.MouseLeave -= Surface_MouseLeave;
                 }
 
                 if (Overlay != null)
                 {
-                    Overlay.IsVisibleChanged -= Overlay_IsVisibleChanged;                        
+                    Overlay.IsVisibleChanged -= Overlay_IsVisibleChanged;
+                    Overlay.MouseLeave -= Overlay_MouseLeave;
                 }
 
                 if (Player != null)
@@ -1212,28 +1558,21 @@ public void Dispose()
                 Player  = null;
             }
         }
+        #endregion
     }
 
-    public enum AttachedDragMoveMode
+    public enum AvailableWindows
     {
-        None,
-        Owner,
-        Self,
+        None, Surface, Overlay, Both
     }
 
-    public enum ResizeMode
+    public enum AttachedDragMoveOptions
     {
-        None,
-        Attached,
-        Detached,
-        Both
+        None, Surface, Overlay, Both, SurfaceOwner, OverlayOwner, BothOwner
     }
 
-    public enum AvailableWindows
+    public enum DetachedPositionOptions
     {
-        None,
-        Surface,
-        Overlay,
-        Both
+        Custom, TopLeft, TopCenter, TopRight, CenterLeft, CenterCenter, CenterRight, BottomLeft, BottomCenter, BottomRight
     }
 }
\ No newline at end of file
diff --git a/FlyleafLib/Controls/WinForms/FlyleafHost.cs b/FlyleafLib/Controls/WinForms/FlyleafHost.cs
index 20955488..d5f35290 100644
--- a/FlyleafLib/Controls/WinForms/FlyleafHost.cs
+++ b/FlyleafLib/Controls/WinForms/FlyleafHost.cs
@@ -54,6 +54,9 @@ public bool         ToggleFullScreenOnDoubleClick
         bool _PanMove = true;
         public bool         PanMove         { get => _PanMove; set => Set(ref _PanMove, value); }
 
+        bool _PanZoom = true;
+        public bool         PanZoom         { get => _PanZoom; set => Set(ref _PanZoom, value); }
+
         bool _DragMove = true;
         public bool         DragMove        { get => _DragMove; set => Set(ref _DragMove, value); }
 
@@ -106,7 +109,7 @@ private void Host_DragDrop(object sender, DragEventArgs e)
         private void Host_DragEnter(object sender, DragEventArgs e) { if (Player != null) e.Effect = DragDropEffects.All; }
         private void Host_MouseWheel(object sender, MouseEventArgs e)
         {
-            if (PanMove && Player != null && e.Delta != 0 && ModifierKeys.HasFlag(Keys.Control))
+            if (PanZoom && Player != null && e.Delta != 0 && ModifierKeys.HasFlag(Keys.Control))
             {
                 Player.Zoom += e.Delta > 0 ? Player.Config.Player.ZoomOffset : -Player.Config.Player.ZoomOffset;
             }
diff --git a/FlyleafLib/FlyleafLib.csproj b/FlyleafLib/FlyleafLib.csproj
index 7657af43..3374fdc5 100644
--- a/FlyleafLib/FlyleafLib.csproj
+++ b/FlyleafLib/FlyleafLib.csproj
@@ -8,7 +8,7 @@
 	<PackageIconUrl />
 	<RepositoryUrl></RepositoryUrl>
 	<Description>Media Player .NET Library for WPF/WinForms (based on FFmpeg/DirectX)</Description>
-	<Version>3.6-pre</Version>
+	<Version>3.6-pre2</Version>
 	<Authors>SuRGeoNix</Authors>
 	<Copyright>SuRGeoNix © 2022</Copyright>
 	<PackageLicenseExpression>LGPL-3.0-or-later</PackageLicenseExpression>
@@ -17,24 +17,10 @@
 	<IncludeSymbols>true</IncludeSymbols>
     <SymbolPackageFormat>snupkg</SymbolPackageFormat>
     <PackageReleaseNotes>
-		- Introduces FlyleafHost Renderer D3D Surface (WPF VideoView's replacement and Flyleaf's for Winforms)
-		* Early and fast initialization of handles and renderer which will also resolve several issues (related to #204)
-		* Adds Attach / Detach functionality
-		* Self Drag Move also on attach mode (within the host's owner bounds)
-		* Drag n Drop Swap between FlyleafHosts (Shift + Drag)
-		* Custom non-borders resizable windows both on attach and detach mode
-		* Better UI Performance overall (including Swaps and Switching between Normal to Full Screen)
-		* Adds Z-order surfaces support (related to #149)
-		* Resolves several issues when the host's rectangle was clipped (related to #170)
-		* Adds support for WPF Windows to the Renderer in addition to WinForms UserControl
-		* Code clean-up and performance improvements
-		* Resolves several issues with DPI (related to #197)
-
-		- Breaking Changes
-		* VideoView has been renamed to FlyleafHost
-		* Player.IsFullScreen, Config.Player.ActivityTimeout, Config.Player.MouseBindings and Config.Player.KeyBindings.(Enabled/FlyleafWindow) has been transferred to FlyleafHost (see .cs)
-		* Player.ActivityMode has been removed (its the same as ActivityTimeout=0) however Player.Activity.IsEnabled to temporary turn it on/off
-		* Swap has been removed as you can now set directly the Players to FlyleafHosts
+		* WPF.FlyleafHost: Adds support for resize based on Player's aspect ratio
+		* WPF.FlyleafHost: Adds more options for detached positioning/sizing
+		* WPF.FlyleafHost: Adds all the functionality also for the Overlay
+		* WPF.FlyleafHost: Finishes up the new implementation (more renamings, see Controls/WPF/FlyleafHost.cs for details)
 	</PackageReleaseNotes>
   </PropertyGroup>
 
diff --git a/FlyleafLib/MediaPlayer/Player.Keys.cs b/FlyleafLib/MediaPlayer/Player.Keys.cs
index bbd89bda..bf13cf2c 100644
--- a/FlyleafLib/MediaPlayer/Player.Keys.cs
+++ b/FlyleafLib/MediaPlayer/Player.Keys.cs
@@ -198,6 +198,24 @@ public void Add(Key key, KeyBindingAction action, bool alt = false, bool ctrl =
             }
         }
 
+        public bool Exists(string actionName)
+        {
+            foreach (var keybinding in Keys)
+                if (keybinding.ActionName == actionName)
+                    return true;
+
+            return false;
+        }
+
+        public KeyBinding Get(string actionName)
+        {
+            foreach (var keybinding in Keys)
+                if (keybinding.ActionName == actionName)
+                    return keybinding;
+
+            return null;
+        }
+
         /// <summary>
         /// Removes a binding based on Key/Ctrl combination
         /// </summary>
diff --git a/FlyleafLib/Themes/Generic.xaml b/FlyleafLib/Themes/Generic.xaml
index 3967b191..0fb9a8aa 100644
--- a/FlyleafLib/Themes/Generic.xaml
+++ b/FlyleafLib/Themes/Generic.xaml
@@ -8,21 +8,29 @@
         <Setter Property="ActivityTimeout" Value="0"/>
         <Setter Property="IsAttached" Value="True"/>
         <Setter Property="IsFullScreen" Value="False"/>
-        <Setter Property="RememberLastDetachedRect" Value="True"/>
-        <Setter Property="TopMost" Value="True"/>
-        <Setter Property="AllowDrop" Value="True"/>
-
-        <Setter Property="DragMoveOnAttach" Value="Owner"/>
-        <Setter Property="DragMoveOnDetach" Value="True"/>
-        <Setter Property="PanMove" Value="True"/>
-        <Setter Property="ToggleFullScreenOnDoubleClick" Value="True"/>
-
-        <Setter Property="ResizeMode" Value="Both"/>
-        <Setter Property="ResizeOnAttach" Value="False"/>
-        <Setter Property="ResizeOnDetach" Value="True"/>
+        <Setter Property="KeyBindings" Value="Surface"/>
+        
+        <Setter Property="OpenOnDrop" Value="Surface"/>
+        <Setter Property="SwapOnDrop" Value="Surface"/>
+        <Setter Property="SwapDragEnterWithShift" Value="Surface"/>
+        
+        <Setter Property="ToggleFullScreenOnDoubleClick" Value="Surface"/>
+        
+        <Setter Property="AttachedResize" Value="None"/>
+        <Setter Property="DetachedResize" Value="Surface"/>
         <Setter Property="ResizeSensitivity" Value="6"/>
-        <Setter Property="KeyBindingsMode" Value="Surface"/>
+        <Setter Property="KeepRatioOnResize" Value="False"/>
+
+        <Setter Property="AttachedDragMove" Value="SurfaceOwner"/>
+        <Setter Property="DetachedDragMove" Value="Surface"/>
 
+        <Setter Property="DetachedRememberPosition" Value="True"/>
+        <Setter Property="DetachedRememberSize" Value="True"/>
+        <Setter Property="DetachedTopMost" Value="False"/>
+        
+        <Setter Property="PanMoveWithCtrl" Value="Surface"/>
+        <Setter Property="PanZoomWithCtrlWheel" Value="Surface"/>
+        
         <Setter Property="Template">
             <Setter.Value>
                 <ControlTemplate TargetType="{x:Type fl:FlyleafHost}">
diff --git a/Samples/FlyleafPlayer (Custom - MVVM) (WPF)/MainWindow.xaml b/Samples/FlyleafPlayer (Custom - MVVM) (WPF)/MainWindow.xaml
index c80fc71d..a6c80bf2 100644
--- a/Samples/FlyleafPlayer (Custom - MVVM) (WPF)/MainWindow.xaml	
+++ b/Samples/FlyleafPlayer (Custom - MVVM) (WPF)/MainWindow.xaml	
@@ -11,7 +11,7 @@
         Title="Flyleaf Player (Custom - MVVM)" Height="650" Width="800" Background="Black">
     
     <Grid>
-        <fl:FlyleafHost Player="{Binding Player}" KeyBindingsMode="Surface">
+        <fl:FlyleafHost Player="{Binding Player}" KeyBindings="Surface">
             <Grid Margin="50">
                 
                 <!-- NOTE: Window resources will not be within the videoview as it will be on different window -->
diff --git a/Samples/FlyleafPlayer (WPF Control) (WPF)/App.xaml.cs b/Samples/FlyleafPlayer (WPF Control) (WPF)/App.xaml.cs
index fa4e1bd9..92b8a554 100644
--- a/Samples/FlyleafPlayer (WPF Control) (WPF)/App.xaml.cs	
+++ b/Samples/FlyleafPlayer (WPF Control) (WPF)/App.xaml.cs	
@@ -1,17 +1,63 @@
 using System;
-using System.Collections.Generic;
-using System.Configuration;
-using System.Data;
-using System.Linq;
-using System.Threading.Tasks;
+using System.IO;
+using System.Threading;
 using System.Windows;
 
-namespace FlyleafPlayer__WPF_Control_
+using FlyleafLib;
+
+namespace FlyleafPlayer
 {
-    /// <summary>
-    /// Interaction logic for App.xaml
-    /// </summary>
     public partial class App : Application
     {
+        public static string CmdUrl { get; set; } = null;
+
+        protected override void OnStartup(StartupEventArgs e)
+        {
+            base.OnStartup(e);
+
+            if (e.Args.Length == 1)
+                CmdUrl = e.Args[0];
+
+            // Ensures that we have enough worker threads to avoid the UI from freezing or not updating on time
+            ThreadPool.GetMinThreads(out int workers, out int ports);
+            ThreadPool.SetMinThreads(workers + 6, ports + 6);
+
+            EngineConfig engineConfig;
+
+            // Engine's Config
+            #if RELEASE
+            if (File.Exists("Flyleaf.Engine.xml"))
+                try { engineConfig = EngineConfig.Load("Flyleaf.Engine.xml"); } catch { engineConfig = DefaultEngineConfig(); }
+            else
+                engineConfig = DefaultEngineConfig();
+            #else
+            engineConfig = DefaultEngineConfig();
+            #endif
+
+            Engine.Start(engineConfig);
+        }
+
+        private EngineConfig DefaultEngineConfig()
+        {
+            EngineConfig engineConfig = new EngineConfig();
+
+            engineConfig.PluginsPath    = ":Plugins";
+            engineConfig.FFmpegPath     = ":FFmpeg";
+            engineConfig.HighPerformaceTimers
+                                        = false;
+            engineConfig.UIRefresh      = true;
+
+            #if RELEASE
+            engineConfig.LogOutput      = "Flyleaf.FirstRun.log";
+            engineConfig.LogLevel       = LogLevel.Debug;
+            engineConfig.FFmpegDevices  = true;
+            #else
+            engineConfig.LogOutput      = ":debug";
+            engineConfig.LogLevel       = LogLevel.Debug;
+            engineConfig.FFmpegLogLevel = FFmpegLogLevel.Warning;
+            #endif
+
+            return engineConfig;
+        }
     }
 }
diff --git a/Samples/FlyleafPlayer (WPF Control) (WPF)/MainWindow.xaml b/Samples/FlyleafPlayer (WPF Control) (WPF)/MainWindow.xaml
index f2883cd7..c5520df7 100644
--- a/Samples/FlyleafPlayer (WPF Control) (WPF)/MainWindow.xaml	
+++ b/Samples/FlyleafPlayer (WPF Control) (WPF)/MainWindow.xaml	
@@ -14,8 +14,8 @@
         TextOptions.TextFormattingMode="Ideal" 
         TextOptions.TextRenderingMode="Auto"
         WindowStyle="None" ResizeMode="NoResize"
-        MinWidth="200" MinHeight="200"
-        Title="Flyleaf v3.6" Height="450" Width="800" Background="Transparent" Loaded="Window_Loaded" Icon="/Flyleaf.ico">
+        MinWidth="150" MinHeight="80"
+        Height="450" Width="800" Background="Transparent" Loaded="Window_Loaded" Icon="/Flyleaf.ico">
 
     <Window.Resources>
         <d:ResourceDictionary Source="pack://application:,,,/FlyleafLib.Controls.WPF;component/Resources/MaterialDesignColors.xaml"/>
@@ -70,7 +70,10 @@
                     <RowDefinition Height="auto"/>
                     <RowDefinition Height="*"/>
                 </Grid.RowDefinitions>
-                <Grid Grid.Row="0" Background="#53000000" x:Name="HeaderGrid">
+                <Grid Grid.Row="0" x:Name="HeaderGrid">
+                    <Grid.Background>
+                        <SolidColorBrush Color="{Binding Player.Config.Video.BackgroundColor}" Opacity="0.15"/>
+                    </Grid.Background>
                     <Grid.RowDefinitions>
                         <RowDefinition Height="50"/>
                     </Grid.RowDefinitions>
@@ -81,28 +84,31 @@
                     </Grid.ColumnDefinitions>
                     <Grid.Style>
                         <Style TargetType="{x:Type Grid}">
-                                <Style.Triggers>
-                                    <DataTrigger Binding="{Binding Player.Activity.Mode}" Value="Idle">
-                                        <DataTrigger.EnterActions>
-                                            <RemoveStoryboard BeginStoryboardName="fadeInN" />
-                                            <BeginStoryboard x:Name="fadeOutN" Storyboard="{StaticResource fadeOut}" />
-                                        </DataTrigger.EnterActions>
-                                    </DataTrigger>
-                                    <DataTrigger Binding="{Binding Player.Activity.Mode, FallbackValue=FullActive, TargetNullValue=FullActive}" Value="FullActive">
-                                        <DataTrigger.EnterActions>
-                                            <RemoveStoryboard BeginStoryboardName="fadeOutN" />
-                                            <BeginStoryboard x:Name="fadeInN" Storyboard="{StaticResource fadeIn}" />
-                                        </DataTrigger.EnterActions>
-                                    </DataTrigger>
-                                </Style.Triggers>
-                            </Style>
+                            <Style.Triggers>
+                                <DataTrigger Binding="{Binding Player.Activity.Mode}" Value="Idle">
+                                    <DataTrigger.EnterActions>
+                                        <RemoveStoryboard BeginStoryboardName="fadeInN" />
+                                        <BeginStoryboard x:Name="fadeOutN" Storyboard="{StaticResource fadeOut}" />
+                                    </DataTrigger.EnterActions>
+                                </DataTrigger>
+                                <DataTrigger Binding="{Binding Player.Activity.Mode, FallbackValue=FullActive, TargetNullValue=FullActive}" Value="FullActive">
+                                    <DataTrigger.EnterActions>
+                                        <RemoveStoryboard BeginStoryboardName="fadeOutN" />
+                                        <BeginStoryboard x:Name="fadeInN" Storyboard="{StaticResource fadeIn}" />
+                                    </DataTrigger.EnterActions>
+                                </DataTrigger>
+                            </Style.Triggers>
+                        </Style>
                     </Grid.Style>
-
-                    <Image Source="Flyleaf.ico" Stretch="UniformToFill" Height="40" Margin="5 0 0 0" VerticalAlignment="Center" ToolTip="Flyleaf v3.6"/>
-
+                    
+                    <Image Source="Flyleaf.ico" Stretch="UniformToFill" Height="40" Margin="5 0 0 0" VerticalAlignment="Center" ToolTip="Flyleaf v3.6-pre2"/>
+                    
                     <TextBlock Grid.ColumnSpan="3" HorizontalAlignment="Center" VerticalAlignment="Center" Text="Flyleaf" FontWeight="Bold" FontStyle="Italic" FontFamily="Mistral" FontSize="34" Foreground="{DynamicResource PrimaryHueMidBrush}"/>
 
                     <StackPanel Grid.Column="2" Orientation="Horizontal" VerticalAlignment="Center" HorizontalAlignment="Right">
+                        <ToggleButton Style="{StaticResource MaterialDesignActionToggleButton}" ToolTip="Always on Top" Background="Transparent" Foreground="{DynamicResource PrimaryHueMidBrush}"
+                                  Content="{materialDesign:PackIcon Kind=PinOutline}" materialDesign:ToggleButtonAssist.OnContent="{materialDesign:PackIcon Kind=Pin}" IsChecked="{Binding DetachedTopMost}"/>
+                        
                         <Button Focusable="False" x:Name="BtnMinimize" Content="{materialDesign:PackIcon Kind=Minimize,Size=30}" VerticalContentAlignment="Bottom" Style="{StaticResource MaterialDesignIconButton}" Click="BtnMinimize_Click"/>
                         <ToggleButton Grid.Column="6" Style="{StaticResource MaterialDesignActionToggleButton}" Foreground="{DynamicResource PrimaryHueMidBrush}" Background="Transparent" Focusable="False"
                                                           IsChecked="{Binding Player.WPFHost.IsFullScreen}" 
@@ -121,7 +127,7 @@
                     <fl:PlayerDebug VerticalAlignment="Center" HorizontalAlignment="Center" Player="{Binding Player}" BoxColor="#AA000000" HeaderColor="White" InfoColor="{DynamicResource PrimaryHueLightBrush}" ValueColor="{DynamicResource SecondaryHueLightBrush}" Visibility="{Binding ShowDebug, Converter={StaticResource BooleanToVisibility}, FallbackValue=Collapsed, TargetNullValue=Collapsed}"/>
 
                     <!--Subtitles-->
-                    <TextBlock Margin="{Binding UIConfig.SubsMargin}" VerticalAlignment="Bottom" HorizontalAlignment="Center" TextAlignment="Center" TextWrapping="Wrap" FontFamily="{Binding UIConfig.SubsFontFamily}" FontSize="{Binding UIConfig.SubsFontSize}" Foreground="{Binding UIConfig.SubsFontColor, Converter={StaticResource ColorToBrush}}" FontWeight="{Binding UIConfig.SubsFontWeight}" Text="{Binding Player.Subtitles.SubsText}">
+                    <TextBlock Margin="{Binding UIConfig.SubsMargin}" VerticalAlignment="Bottom" HorizontalAlignment="Center" TextAlignment="Center" TextWrapping="Wrap" FontFamily="{Binding UIConfig.SubsFontFamily}" FontSize="{Binding UIConfig.SubsFontSize}" Foreground="{Binding UIConfig.SubsFontColor, Converter={StaticResource ColorToBrush}}" FontWeight="{Binding UIConfig.SubsFontWeight}" FontStyle="{Binding UIConfig.SubsFontStyle}" Text="{Binding Player.Subtitles.SubsText}">
                         <TextBlock.Effect>
                             <DropShadowEffect ShadowDepth="2" Direction="0" Color="{Binding Player.Config.Video.BackgroundColor}" Opacity="1.0" BlurRadius="0"/>
                         </TextBlock.Effect>
diff --git a/Samples/FlyleafPlayer (WPF Control) (WPF)/MainWindow.xaml.cs b/Samples/FlyleafPlayer (WPF Control) (WPF)/MainWindow.xaml.cs
index 683e15a3..16c6f9e3 100644
--- a/Samples/FlyleafPlayer (WPF Control) (WPF)/MainWindow.xaml.cs	
+++ b/Samples/FlyleafPlayer (WPF Control) (WPF)/MainWindow.xaml.cs	
@@ -17,36 +17,21 @@ public partial class MainWindow : Window
         /// <summary>
         /// Flyleaf Player binded to FlyleafME
         /// </summary>
-        public Player       PlayerX     { get; set; }
+        public Player       Player      { get; set; }
 
         /// <summary>
         /// FlyleafME Media Element Control
         /// </summary>
         public FlyleafME    FlyleafME   { get; set; }
 
-        EngineConfig engineConfig;
+        
         Config playerConfig;
+        bool ReversePlaybackChecked;
 
         public MainWindow()
         {
             // NOTE: Loads/Saves configs only in RELEASE mode
 
-            // Ensures that we have enough worker threads to avoid the UI from freezing or not updating on time
-            ThreadPool.GetMinThreads(out int workers, out int ports);
-            ThreadPool.SetMinThreads(workers + 6, ports + 6);
-
-            // Engine's Config
-            #if RELEASE
-            if (File.Exists("Flyleaf.Engine.xml"))
-                try { engineConfig = EngineConfig.Load("Flyleaf.Engine.xml"); } catch { engineConfig = DefaultEngineConfig(); }
-            else
-                engineConfig = DefaultEngineConfig();
-            #else
-            engineConfig = DefaultEngineConfig();
-            #endif
-
-            Engine.Start(engineConfig);
-
             // Player's Config (Cannot be initialized before Engine's initialization)
             #if RELEASE
             // Load Player's Config
@@ -59,15 +44,18 @@ public MainWindow()
             #endif
             
             // Initializes the Player
-            PlayerX = new Player(playerConfig);
+            Player = new Player(playerConfig);
 
             FlyleafME = new FlyleafME(this)
             {
                 ActivityTimeout = 2000,
-                KeyBindingsMode = AvailableWindows.Both,
-                ResizeMode = AvailableWindows.Overlay,
-                DragMoveOnDetach = true,
-                Player = PlayerX
+                KeyBindings = AvailableWindows.Both,
+                DetachedResize = AvailableWindows.Overlay,
+                DetachedDragMove = AvailableWindows.Both,
+                ToggleFullScreenOnDoubleClick = AvailableWindows.Both,
+                KeepRatioOnResize = true,
+
+                Player = Player
             };
 
             InitializeComponent();
@@ -80,16 +68,8 @@ public MainWindow()
             FlyleafME.EnginePath    = "Flyleaf.Engine.xml";
             FlyleafME.UIConfigPath  = "Flyleaf.UIConfig.xml";
 
-            MouseLeftButtonDown += (o, e) =>
-            { 
-                if (e.ClickCount == 2)
-                    FlyleafME.IsFullScreen = !FlyleafME.IsFullScreen;
-                else if (FlyleafME.ResizingSideOverlay == 0 && e.ClickCount == 1) 
-                    DragMove();
-            };
-
             // If the user requests reverse playback allocate more frames once
-            PlayerX.PropertyChanged += (o, e) =>
+            Player.PropertyChanged += (o, e) =>
             {
                 if (e.PropertyName == "ReversePlayback" && !ReversePlaybackChecked)
                 {
@@ -99,31 +79,23 @@ public MainWindow()
                     ReversePlaybackChecked = true;
                 }
             };
-        }
-        bool ReversePlaybackChecked;
 
-        private EngineConfig DefaultEngineConfig()
-        {
-            EngineConfig engineConfig = new EngineConfig();
+            // TODO: Extend FlyleafME's PopUp Menu to include those
+            // Ctrl+ N / Ctrl + W (Open New/Close Window)
+            var key = playerConfig.Player.KeyBindings.Get("New Window");
+            if (key != null)
+                key.SetAction(() => (new MainWindow()).Show(), true);
+            else
+                playerConfig.Player.KeyBindings.AddCustom(System.Windows.Input.Key.N, true, () => { (new MainWindow()).Show(); }, "New Window", false, true, false);
 
-            engineConfig.PluginsPath    = ":Plugins";
-            engineConfig.FFmpegPath     = ":FFmpeg";
-            engineConfig.HighPerformaceTimers
-                                        = false;
-            engineConfig.UIRefresh      = true;
+            key = playerConfig.Player.KeyBindings.Get("Close Window");
+            if (key != null)
+                key.SetAction(() => Close(), true);
+            else
+                playerConfig.Player.KeyBindings.AddCustom(System.Windows.Input.Key.W, true, () => { Close(); }, "Close Window", false, true, false);
+        }
 
-            #if RELEASE
-            engineConfig.LogOutput      = "Flyleaf.FirstRun.log";
-            engineConfig.LogLevel       = LogLevel.Debug;
-            engineConfig.FFmpegDevices  = true;
-            #else
-            engineConfig.LogOutput      = ":debug";
-            engineConfig.LogLevel       = LogLevel.Debug;
-            engineConfig.FFmpegLogLevel = FFmpegLogLevel.Warning;
-            #endif
 
-            return engineConfig;
-        }
 
         private Config DefaultConfig()
         {
@@ -134,8 +106,17 @@ private Config DefaultConfig()
             return config;
         }
 
+        static bool runOnce;
         private void Window_Loaded(object sender, RoutedEventArgs e)
         {
+            if (runOnce)
+                return;
+
+            runOnce = true;
+
+            if (App.CmdUrl != null)
+                Player.OpenAsync(App.CmdUrl);
+
             #if RELEASE
             // Save Player's Config (First Run)
             // Ensures that the Control's handle has been created and the renderer has been fully initialized (so we can save also the filters parsed by the library)
@@ -149,13 +130,13 @@ private void Window_Loaded(object sender, RoutedEventArgs e)
             }
 
             // Stops Logging (First Run)
-            if (!engineConfig.Loaded)
+            if (!Engine.Config.Loaded)
             {
-                engineConfig.LogOutput      = null;
-                engineConfig.LogLevel       = LogLevel.Quiet;
-                engineConfig.FFmpegDevices  = false;
+                Engine.Config.LogOutput      = null;
+                Engine.Config.LogLevel       = LogLevel.Quiet;
+                Engine.Config.FFmpegDevices  = false;
 
-                try { engineConfig.Save("Flyleaf.Engine.xml"); } catch { }
+                try { Engine.Config.Save("Flyleaf.Engine.xml"); } catch { }
             }
             #endif
         }
@@ -164,15 +145,5 @@ private void Window_Loaded(object sender, RoutedEventArgs e)
         private void BtnMaximizeRestore_Checked(object sender, RoutedEventArgs e) => WindowState = WindowState.Maximized;
         private void BtnMaximizeRestore_Unchecked(object sender, RoutedEventArgs e) => WindowState = WindowState.Normal;
         private void BtnClose_Click(object sender, RoutedEventArgs e) => Close();
-        private void Grid_MouseLeftButtonDown(object sender, System.Windows.Input.MouseButtonEventArgs e)
-        {
-            if (e.ClickCount == 2)
-            {
-                WindowState = WindowState == WindowState.Maximized ? WindowState.Normal : WindowState.Maximized;
-                return;
-            }
-
-            DragMove();
-        }
     }
 }
diff --git a/Tests/DoubleVideoViewOverlay/MainWindow.xaml b/Tests/DoubleVideoViewOverlay/MainWindow.xaml
index 58b7ab1f..f1be77e6 100644
--- a/Tests/DoubleVideoViewOverlay/MainWindow.xaml
+++ b/Tests/DoubleVideoViewOverlay/MainWindow.xaml
@@ -20,7 +20,7 @@
                 </StackPanel>
 
                 <fl:FlyleafHost x:Name="SeekView" Player="{Binding PlayerSeek}" BorderThickness="3" BorderBrush="Green" Width="100" Height="100" VerticalAlignment="Bottom" Focusable="True" Margin="0 0 0 15"
-                              KeyBindingsMode="None" DragMoveOnAttach="None" ToggleFullScreenOnDoubleClick="False" PanMove="False"
+                              KeyBindings="None" AttachedDragMove="None" ToggleFullScreenOnDoubleClick="Both" PanMoveWithCtrl="None" PanZoomWithCtrlWheel="None"
                               />
 
                 <StackPanel VerticalAlignment="Bottom" HorizontalAlignment="Center">
diff --git a/Tests/FlyleafMultiPlayer (WPF)/FlyleafMEOverride.xaml b/Tests/FlyleafMultiPlayer (WPF)/FlyleafMEOverride.xaml
index 57863a9f..4c21d6ef 100644
--- a/Tests/FlyleafMultiPlayer (WPF)/FlyleafMEOverride.xaml	
+++ b/Tests/FlyleafMultiPlayer (WPF)/FlyleafMEOverride.xaml	
@@ -30,7 +30,7 @@
     
     <Style TargetType="{x:Type flwpf:FlyleafME}" BasedOn="{StaticResource {x:Type fl:FlyleafHost}}" x:Shared="False" x:Key="DISABLED">
         <Setter Property="ActivityTimeout" Value="0"/>
-        <Setter Property="KeyBindingsMode" Value="Both"/>
+        <Setter Property="KeyBindings" Value="Both"/>
         <Setter Property="Content">
             <Setter.Value>
                 <Border BorderThickness="0.6">
diff --git a/Tests/WpfFlyleafHost/MultipleAttached.xaml b/Tests/WpfFlyleafHost/MultipleAttached.xaml
index d28a8e7d..b99f669c 100644
--- a/Tests/WpfFlyleafHost/MultipleAttached.xaml
+++ b/Tests/WpfFlyleafHost/MultipleAttached.xaml
@@ -25,7 +25,7 @@
         
         <!--Overlay Border / Resize on Overlay (Recommended)-->
         <fl:FlyleafHost Width="140" Height="110" Margin="100 300 0 0" VerticalAlignment="Top" HorizontalAlignment="Left"
-                        DragMoveOnAttach="Self" ResizeMode="Overlay" ResizeOnAttach="True">
+                        AttachedDragMove="Surface" AttachedResize="Surface">
             <Border BorderBrush="DarkBlue" BorderThickness="4">
                 <Viewbox>
                     <TextBlock Text="Inner Border" Foreground="DarkRed" TextWrapping="Wrap" VerticalAlignment="Center" HorizontalAlignment="Center"/>
@@ -37,15 +37,25 @@
         <Border x:Name="BorderMarginTarget" Margin="200 100 0 0" VerticalAlignment="Top" HorizontalAlignment="Left"
                 BorderBrush="DarkBlue" BorderThickness="4">
             <fl:FlyleafHost Width="100" Height="50"
-                            DragMoveOnAttach="Self" ResizeMode="Surface" ResizeOnAttach="True" MarginTarget="{Binding ElementName=BorderMarginTarget}">
+                            AttachedDragMove="Surface" AttachedResize="Surface" MarginTarget="{Binding ElementName=BorderMarginTarget}">
             </fl:FlyleafHost>
         </Border>
         
         <!--Attach / Detach-->
-        <fl:FlyleafHost Margin="300 200 0 0" Width="140" Height="110" VerticalAlignment="Top" HorizontalAlignment="Left"
-                        DragMoveOnAttach="Self" ResizeMode="Overlay" ResizeOnAttach="True" IsAttached="False" TopMost="True"
-                        RememberLastDetachedRect="False" DetachedRect="800 700 300 200">
-            
+        <fl:FlyleafHost Player="{Binding Player1}" Margin="300 200 0 0" Width="140" Height="110" VerticalAlignment="Top" HorizontalAlignment="Left"
+                        AttachedDragMove="Surface" AttachedResize="Overlay"
+                        DetachedDragMove="Both" DetachedResize="Overlay" DetachedTopMost="True"
+                        
+                        IsAttached="False"
+                        KeepRatioOnResize="True"
+                        
+                        DetachedRememberPosition="True" DetachedRememberSize="True"
+                        DetachedFixedPosition="100 100" DetachedFixedSize="350 200"
+                        DetachedPosition="BottomRight" DetachedPositionMargin="0 0 10 50"
+                        
+                        PanMoveWithCtrl="None" PanZoomWithCtrlWheel="None"
+                        >
+
             <fl:FlyleafHost.DetachedContent>
                 <Border DataContext="{Binding RelativeSource={RelativeSource Mode=FindAncestor, AncestorType={x:Type fl:FlyleafHost}}}" BorderBrush="DarkBlue" BorderThickness="4">
                     <Border.Style>
@@ -78,9 +88,8 @@
                     <Style TargetType="{x:Type fl:FlyleafHost}" BasedOn="{StaticResource {x:Type fl:FlyleafHost}}">
                         <Setter Property="Width" Value="200"/>
                         <Setter Property="Height" Value="100"/>
-                        <Setter Property="ResizeMode" Value="Surface"/>
-                        <Setter Property="ResizeOnAttach" Value="True"/>
-                        <Setter Property="DragMoveOnAttach" Value="Self"/>
+                        <Setter Property="AttachedResize" Value="Surface"/>
+                        <Setter Property="AttachedDragMove" Value="Surface"/>
                         <Setter Property="VerticalAlignment" Value="Top"/>
                         <Setter Property="HorizontalAlignment" Value="Left"/>
                         <Setter Property="Player" Value="{DynamicResource {x:Type fl1:Player}}"/>
@@ -117,13 +126,13 @@
         <ScrollViewer Background="Bisque" Margin="200 300 0 0" Width="200" Height="100" HorizontalScrollBarVisibility="Disabled" VerticalScrollBarVisibility="Auto" HorizontalContentAlignment="Center" HorizontalAlignment="Center">
             <StackPanel x:Name="FixMyScrollSurfaceOverlay">
                 <fl:FlyleafHost Width="100" Height="150"
-                            DragMoveOnAttach="None" ResizeMode="None" ResizeOnAttach="False" MarginTarget="{Binding ElementName=BorderMarginTarget}">
+                            AttachedDragMove="Surface" AttachedResize="Surface">
                     <Viewbox>
                         <TextBlock Text="Screen 1" Foreground="DarkRed"/>
                     </Viewbox>
                 </fl:FlyleafHost>
                 <fl:FlyleafHost Margin="0 20 0 0" Width="100" Height="150"
-                            DragMoveOnAttach="None" ResizeMode="None" ResizeOnAttach="False" MarginTarget="{Binding ElementName=BorderMarginTarget}">
+                            AttachedDragMove="Surface" AttachedResize="Surface">
                     <Viewbox>
                         <TextBlock Text="Screen 2" Foreground="DarkMagenta"/>
                     </Viewbox>
diff --git a/Tests/WpfFlyleafHost/MultipleAttached.xaml.cs b/Tests/WpfFlyleafHost/MultipleAttached.xaml.cs
index c1de10f2..3b4e1218 100644
--- a/Tests/WpfFlyleafHost/MultipleAttached.xaml.cs
+++ b/Tests/WpfFlyleafHost/MultipleAttached.xaml.cs
@@ -4,13 +4,14 @@
 using System.Windows.Input;
 
 using FlyleafLib.Controls.WPF;
+using FlyleafLib.MediaPlayer;
 
 namespace WpfFlyleafHost
 {
     public partial class MultipleAttached : Window
     {
         public string TestDataContext { get; set; } = "MainDataContext";
-
+        public Player Player1 { get; set; } = new Player();
         public MultipleAttached()
         {
             InitializeComponent();
diff --git a/Tests/WpfFlyleafHost/OverlayStandAlone.xaml.cs b/Tests/WpfFlyleafHost/OverlayStandAlone.xaml.cs
index d512daa5..5ed5fe13 100644
--- a/Tests/WpfFlyleafHost/OverlayStandAlone.xaml.cs
+++ b/Tests/WpfFlyleafHost/OverlayStandAlone.xaml.cs
@@ -36,10 +36,9 @@ public OverlayStandAlone()
 
             FlyleafHost = new FlyleafHost(this)
             {
-                KeyBindingsMode = AvailableWindows.Both,
-                ResizeMode = AvailableWindows.Both,
+                KeyBindings = AvailableWindows.Both,
+                DetachedResize = AvailableWindows.Both,
                 IsAttached = false,
-                ResizeOnDetach = true,
 
                 Player = Player
             };