diff --git a/Sample Applications/WPF Application Samples.sln b/Sample Applications/WPF Application Samples.sln
index 17bc4c929..a8b25d905 100644
--- a/Sample Applications/WPF Application Samples.sln	
+++ b/Sample Applications/WPF Application Samples.sln	
@@ -1,19 +1,19 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 14
-VisualStudioVersion = 14.0.23103.0
+# Visual Studio Version 17
+VisualStudioVersion = 17.4.33103.184
 MinimumVisualStudioVersion = 10.0.40219.1
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ConcentricRingsDemo", "ConcentricRingsDemo\ConcentricRingsDemo.csproj", "{0C7755BD-E5D1-4CB1-8271-445863408B5B}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ConcentricRingsDemo", "ConcentricRingsDemo\ConcentricRingsDemo.csproj", "{0C7755BD-E5D1-4CB1-8271-445863408B5B}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CubeAnimationDemo", "CubeAnimationDemo\CubeAnimationDemo.csproj", "{8EF611EF-44AD-4871-9CF9-A80D501A1300}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CubeAnimationDemo", "CubeAnimationDemo\CubeAnimationDemo.csproj", "{8EF611EF-44AD-4871-9CF9-A80D501A1300}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CustomComboBox", "CustomComboBox\CustomComboBox.csproj", "{9E3EECAF-86CF-45CB-8ABB-01A850A308F0}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CustomComboBox", "CustomComboBox\CustomComboBox.csproj", "{9E3EECAF-86CF-45CB-8ABB-01A850A308F0}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DataBindingDemo", "DataBindingDemo\DataBindingDemo.csproj", "{D56C3A49-C7A9-42E5-9C59-AF1670B08276}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DataBindingDemo", "DataBindingDemo\DataBindingDemo.csproj", "{D56C3A49-C7A9-42E5-9C59-AF1670B08276}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DropShadow", "DropShadow\DropShadow.csproj", "{5E760E96-A59B-491D-9FDC-70587AE24240}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DropShadow", "DropShadow\DropShadow.csproj", "{5E760E96-A59B-491D-9FDC-70587AE24240}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EditingExaminerDemo", "EditingExaminerDemo\EditingExaminerDemo.csproj", "{E689F47C-198B-4E3C-941D-81BD73D61B2C}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "EditingExaminerDemo", "EditingExaminerDemo\EditingExaminerDemo.csproj", "{E689F47C-198B-4E3C-941D-81BD73D61B2C}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ExpenseItDemo", "ExpenseItDemo\ExpenseItDemo.csproj", "{D1729F17-99A5-45AF-AB38-72FA6ECCE609}"
 EndProject
@@ -21,41 +21,43 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ExpenseIt", "ExpenseIt", "{
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "EditBoxControlLibrary", "EditBoxControlLibrary\EditBoxControlLibrary.csproj", "{558EEE03-6927-4FE6-AEB6-972769960849}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FontDialogDemo", "FontDialog\FontDialogDemo.csproj", "{18DA881E-FE67-46E6-95E5-6FDC99331E2B}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "FontDialogDemo", "FontDialog\FontDialogDemo.csproj", "{18DA881E-FE67-46E6-95E5-6FDC99331E2B}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GeometryDesignerDemo", "GeometryDesignerDemo\GeometryDesignerDemo.csproj", "{FBA69105-5C42-44A4-82E6-0BF3BC09F2A5}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GeometryDesignerDemo", "GeometryDesignerDemo\GeometryDesignerDemo.csproj", "{FBA69105-5C42-44A4-82E6-0BF3BC09F2A5}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GraphingCalculatorDemo", "GraphingCalculatorDemo\GraphingCalculatorDemo.csproj", "{1C45AF74-269B-4828-A054-6D0761304E61}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GraphingCalculatorDemo", "GraphingCalculatorDemo\GraphingCalculatorDemo.csproj", "{1C45AF74-269B-4828-A054-6D0761304E61}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HexSphereDemo", "HexSphereDemo\HexSphereDemo.csproj", "{48FC0038-9FDF-443C-B24B-9418C8956100}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "HexSphereDemo", "HexSphereDemo\HexSphereDemo.csproj", "{48FC0038-9FDF-443C-B24B-9418C8956100}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LayoutTransitionsDemo", "LayoutTransitionsDemo\LayoutTransitionsDemo.csproj", "{9CB40026-7C2F-441F-B496-CDBB454AC309}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "LayoutTransitionsDemo", "LayoutTransitionsDemo\LayoutTransitionsDemo.csproj", "{9CB40026-7C2F-441F-B496-CDBB454AC309}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LogonScreenDemo", "LogonScreenDemo\LogonScreenDemo.csproj", "{20B6AAAA-E9A8-43B6-83A8-E855206269B2}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NotepadDemo", "NotepadDemo\NotepadDemo.csproj", "{AC0A939B-050C-46B5-9EC8-F5349616AD03}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ParticlesDemo", "ParticlesDemo\ParticlesDemo.csproj", "{F10AB8C9-CE19-44D6-BEA6-9EBA03850664}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ParticlesDemo", "ParticlesDemo\ParticlesDemo.csproj", "{F10AB8C9-CE19-44D6-BEA6-9EBA03850664}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PhotoFlipperDemo", "PhotoFlipperDemo\PhotoFlipperDemo.csproj", "{769F1C36-6975-4390-8D67-9E50A42D2755}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "PhotoFlipperDemo", "PhotoFlipperDemo\PhotoFlipperDemo.csproj", "{769F1C36-6975-4390-8D67-9E50A42D2755}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PhotoStoreDemo", "PhotoStoreDemo\PhotoStoreDemo.csproj", "{D6567F46-7604-4714-9785-F99341AE5C81}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "PhotoStoreDemo", "PhotoStoreDemo\PhotoStoreDemo.csproj", "{D6567F46-7604-4714-9785-F99341AE5C81}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "StickyNotesDemo", "StickyNotesDemo\StickyNotesDemo.csproj", "{4CB08E17-0C15-4F66-8659-003D39E576BA}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "StickyNotesDemo", "StickyNotesDemo\StickyNotesDemo.csproj", "{4CB08E17-0C15-4F66-8659-003D39E576BA}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SlidePuzzleDemo", "SlidePuzzleDemo\SlidePuzzleDemo.csproj", "{587E93FE-3686-4AE0-88A7-2E067AB0783A}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SlidePuzzleDemo", "SlidePuzzleDemo\SlidePuzzleDemo.csproj", "{587E93FE-3686-4AE0-88A7-2E067AB0783A}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TrafficAlertDemo", "TrafficAlertDemo\TrafficAlertDemo.csproj", "{0980E7C5-85A6-4451-B9E0-71EB4CDEC52A}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CalculatorDemo", "CalculatorDemo\CalculatorDemo.csproj", "{5731865D-6685-47A7-8877-5DBAF39B54CD}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CalculatorDemo", "CalculatorDemo\CalculatorDemo.csproj", "{5731865D-6685-47A7-8877-5DBAF39B54CD}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VideoTextDemo", "VideoTextDemo\VideoTextDemo.csproj", "{8FD5A19E-9F9D-4F54-A2A6-4459A11E292A}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PhotoViewerDemo", "PhotoViewerDemo\PhotoViewerDemo.csproj", "{77372DB6-7B08-404D-B70E-69CF5ACD865C}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "PhotoViewerDemo", "PhotoViewerDemo\PhotoViewerDemo.csproj", "{77372DB6-7B08-404D-B70E-69CF5ACD865C}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VideoViewerDemo", "VideoViewerDemo\VideoViewerDemo.csproj", "{439F91F2-9A8D-41EF-B9BB-D7CB2BCF3F10}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "VideoViewerDemo", "VideoViewerDemo\VideoViewerDemo.csproj", "{439F91F2-9A8D-41EF-B9BB-D7CB2BCF3F10}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HtmlToXamlDemo", "HtmlToXamlDemo\HtmlToXamlDemo.csproj", "{1AF5ED2C-BB8A-4B12-8CB5-8C8F2E838908}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "HtmlToXamlDemo", "HtmlToXamlDemo\HtmlToXamlDemo.csproj", "{1AF5ED2C-BB8A-4B12-8CB5-8C8F2E838908}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WpfTreeView", "WpfTreeView\WpfTreeView.csproj", "{4DB0B7F2-36D1-4A9D-8EAF-DF4E4A0043E5}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -167,6 +169,10 @@ Global
 		{1AF5ED2C-BB8A-4B12-8CB5-8C8F2E838908}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{1AF5ED2C-BB8A-4B12-8CB5-8C8F2E838908}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{1AF5ED2C-BB8A-4B12-8CB5-8C8F2E838908}.Release|Any CPU.Build.0 = Release|Any CPU
+		{4DB0B7F2-36D1-4A9D-8EAF-DF4E4A0043E5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4DB0B7F2-36D1-4A9D-8EAF-DF4E4A0043E5}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4DB0B7F2-36D1-4A9D-8EAF-DF4E4A0043E5}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4DB0B7F2-36D1-4A9D-8EAF-DF4E4A0043E5}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -175,4 +181,7 @@ Global
 		{D1729F17-99A5-45AF-AB38-72FA6ECCE609} = {07258053-D6F1-4D8F-B3E4-A93423EFDF78}
 		{558EEE03-6927-4FE6-AEB6-972769960849} = {07258053-D6F1-4D8F-B3E4-A93423EFDF78}
 	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {CA7A4369-DB85-4780-872F-FD5AFEA01D0E}
+	EndGlobalSection
 EndGlobal
diff --git a/Sample Applications/WpfTreeView/App.xaml b/Sample Applications/WpfTreeView/App.xaml
new file mode 100644
index 000000000..5327e5aa7
--- /dev/null
+++ b/Sample Applications/WpfTreeView/App.xaml	
@@ -0,0 +1,9 @@
+<Application x:Class="WpfTreeView.App"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:local="clr-namespace:WpfTreeView"
+             StartupUri="MainWindow.xaml">
+    <Application.Resources>
+         
+    </Application.Resources>
+</Application>
diff --git a/Sample Applications/WpfTreeView/App.xaml.cs b/Sample Applications/WpfTreeView/App.xaml.cs
new file mode 100644
index 000000000..99577bc9e
--- /dev/null
+++ b/Sample Applications/WpfTreeView/App.xaml.cs	
@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Configuration;
+using System.Data;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Windows;
+
+namespace WpfTreeView
+{
+    /// <summary>
+    /// Interaction logic for App.xaml
+    /// </summary>
+    public partial class App : Application
+    {
+    }
+}
diff --git a/Sample Applications/WpfTreeView/AssemblyInfo.cs b/Sample Applications/WpfTreeView/AssemblyInfo.cs
new file mode 100644
index 000000000..8b5504ecf
--- /dev/null
+++ b/Sample Applications/WpfTreeView/AssemblyInfo.cs	
@@ -0,0 +1,10 @@
+using System.Windows;
+
+[assembly: ThemeInfo(
+    ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located
+                                     //(used if a resource is not found in the page,
+                                     // or application resource dictionaries)
+    ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located
+                                              //(used if a resource is not found in the page,
+                                              // app, or any theme specific resource dictionaries)
+)]
diff --git a/Sample Applications/WpfTreeView/HeaderToImageConverter.cs b/Sample Applications/WpfTreeView/HeaderToImageConverter.cs
new file mode 100644
index 000000000..d1464dc7b
--- /dev/null
+++ b/Sample Applications/WpfTreeView/HeaderToImageConverter.cs	
@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Windows.Data;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+
+namespace WpfTreeView
+{
+    /// <summary>
+    /// Converts a full path to a specific image type of a drive, folder or file.
+    /// </summary>
+    
+    [ValueConversion(typeof(string), typeof(BitmapImage))]
+    public class HeaderToImageConverter : IValueConverter
+    {
+        public IDictionary<string, ImageSource> KnownFiles { get; set; }
+
+        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            // Get the full Path
+            var path = (string)value;
+
+            // if the path is null, ignore
+            if (path == null)
+                return null;
+
+            // Get the name of the file/folder
+            var name = MainWindow.GetFileFolderName(path);
+
+            // By default, we presume an image
+            var image = "Images/file.png";
+
+            // If the name is blank, we presume it's a drive as we cannot have a blank file or folder name
+            if (string.IsNullOrEmpty(name))
+                image = "Images/drive.png";
+            else if (new FileInfo(path).Attributes.HasFlag(FileAttributes.Directory)) // checks if this path is a directory
+                image = "Images/folder-closed.png";
+            else if (KnownFiles != null && KnownFiles.ContainsKey(Path.GetExtension(path)))
+                return KnownFiles[Path.GetExtension(path)];
+
+            return new BitmapImage(new Uri($"pack://application:,,,/{image}"));
+
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}
diff --git a/Sample Applications/WpfTreeView/Images/c.png b/Sample Applications/WpfTreeView/Images/c.png
new file mode 100644
index 000000000..977a54e89
Binary files /dev/null and b/Sample Applications/WpfTreeView/Images/c.png differ
diff --git a/Sample Applications/WpfTreeView/Images/cpp.png b/Sample Applications/WpfTreeView/Images/cpp.png
new file mode 100644
index 000000000..cd4296f76
Binary files /dev/null and b/Sample Applications/WpfTreeView/Images/cpp.png differ
diff --git a/Sample Applications/WpfTreeView/Images/csharp.png b/Sample Applications/WpfTreeView/Images/csharp.png
new file mode 100644
index 000000000..e75aa963b
Binary files /dev/null and b/Sample Applications/WpfTreeView/Images/csharp.png differ
diff --git a/Sample Applications/WpfTreeView/Images/drive.png b/Sample Applications/WpfTreeView/Images/drive.png
new file mode 100644
index 000000000..377f43c83
Binary files /dev/null and b/Sample Applications/WpfTreeView/Images/drive.png differ
diff --git a/Sample Applications/WpfTreeView/Images/file.png b/Sample Applications/WpfTreeView/Images/file.png
new file mode 100644
index 000000000..d92b73b52
Binary files /dev/null and b/Sample Applications/WpfTreeView/Images/file.png differ
diff --git a/Sample Applications/WpfTreeView/Images/folder-closed.png b/Sample Applications/WpfTreeView/Images/folder-closed.png
new file mode 100644
index 000000000..e8a2bcfb1
Binary files /dev/null and b/Sample Applications/WpfTreeView/Images/folder-closed.png differ
diff --git a/Sample Applications/WpfTreeView/Images/folder-open.png b/Sample Applications/WpfTreeView/Images/folder-open.png
new file mode 100644
index 000000000..a51f879ab
Binary files /dev/null and b/Sample Applications/WpfTreeView/Images/folder-open.png differ
diff --git a/Sample Applications/WpfTreeView/Images/java.png b/Sample Applications/WpfTreeView/Images/java.png
new file mode 100644
index 000000000..97b5426a8
Binary files /dev/null and b/Sample Applications/WpfTreeView/Images/java.png differ
diff --git a/Sample Applications/WpfTreeView/Images/javascript.png b/Sample Applications/WpfTreeView/Images/javascript.png
new file mode 100644
index 000000000..06f906b87
Binary files /dev/null and b/Sample Applications/WpfTreeView/Images/javascript.png differ
diff --git a/Sample Applications/WpfTreeView/Images/json.png b/Sample Applications/WpfTreeView/Images/json.png
new file mode 100644
index 000000000..316907e1e
Binary files /dev/null and b/Sample Applications/WpfTreeView/Images/json.png differ
diff --git a/Sample Applications/WpfTreeView/Images/pdf.png b/Sample Applications/WpfTreeView/Images/pdf.png
new file mode 100644
index 000000000..fa0ace379
Binary files /dev/null and b/Sample Applications/WpfTreeView/Images/pdf.png differ
diff --git a/Sample Applications/WpfTreeView/Images/python.png b/Sample Applications/WpfTreeView/Images/python.png
new file mode 100644
index 000000000..19a271f6e
Binary files /dev/null and b/Sample Applications/WpfTreeView/Images/python.png differ
diff --git a/Sample Applications/WpfTreeView/Images/txt.png b/Sample Applications/WpfTreeView/Images/txt.png
new file mode 100644
index 000000000..51d43a1f5
Binary files /dev/null and b/Sample Applications/WpfTreeView/Images/txt.png differ
diff --git a/Sample Applications/WpfTreeView/Images/xlsx.png b/Sample Applications/WpfTreeView/Images/xlsx.png
new file mode 100644
index 000000000..6e9ac3e66
Binary files /dev/null and b/Sample Applications/WpfTreeView/Images/xlsx.png differ
diff --git a/Sample Applications/WpfTreeView/MainWindow.xaml b/Sample Applications/WpfTreeView/MainWindow.xaml
new file mode 100644
index 000000000..271d695a8
--- /dev/null
+++ b/Sample Applications/WpfTreeView/MainWindow.xaml	
@@ -0,0 +1,92 @@
+<Window x:Class="WpfTreeView.MainWindow"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+        xmlns:local="clr-namespace:WpfTreeView"
+        Loaded="Window_Loaded"
+        mc:Ignorable="d"
+        Name="This"
+        Title="MainWindow" Height="450" Width="800">
+
+    <Window.InputBindings>
+        <KeyBinding Key="C" Modifiers="Ctrl" Command="{Binding ElementName=This, Path=CopyCommand}"/>
+        <KeyBinding Key="V" Modifiers="Ctrl" Command="{Binding ElementName=This, Path=PasteCommand}"/>
+        <KeyBinding Key="X" Modifiers="Ctrl" Command="{Binding ElementName=This, Path=CutCommand}"/>
+    </Window.InputBindings>
+    <Window.Resources>
+        <BitmapImage x:Key="PythonIcon" UriSource="Images/python.png"/>
+        <BitmapImage x:Key="CSharpIcon" UriSource="Images/csharp.png"/>
+        <BitmapImage x:Key="CIcon" UriSource="Images/c.png"/>
+        <BitmapImage x:Key="CppIcon" UriSource="Images/cpp.png"/>
+        <BitmapImage x:Key="JavaIcon" UriSource="Images/java.png"/>
+        <BitmapImage x:Key="JavascriptIcon" UriSource="Images/javascript.png"/>
+        <BitmapImage x:Key="TextIcon" UriSource="Images/txt.png"/>
+        <BitmapImage x:Key="JsonIcon" UriSource="Images/json.png"/>
+        <BitmapImage x:Key="XslxIcon" UriSource="Images/xlsx.png"/>
+        <BitmapImage x:Key="PdfIcon" UriSource="Images/pdf.png"/>
+        <local:HeaderToImageConverter x:Key="ImageConverter"/>
+    </Window.Resources>
+    <Grid>
+        <Grid.RowDefinitions>
+            <RowDefinition Height="auto"/>
+            <RowDefinition/>
+        </Grid.RowDefinitions>
+
+        <StackPanel Orientation="Horizontal" Grid.Row="0">
+            <Button Content="Copy" Command="{Binding ElementName=This, Path=CopyCommand}"/>
+            <Button Content="Paste" Command="{Binding ElementName=This, Path=PasteCommand}"/>
+            <Button Content="Cut" Command="{Binding ElementName=This, Path=CutCommand}"/>
+        </StackPanel>
+        <TreeView x:Name="FolderView"
+                  Grid.Row="1"
+                  SelectedItemChanged="FolderView_SelectedItemChanged"
+                  Focusable="True"
+                  AllowDrop="True">
+            <TreeView.ContextMenu>
+                <ContextMenu>
+                    <MenuItem Header="Refresh" Command="{Binding RefreshCommand}"/>
+                    <MenuItem Header="Copy" Command="{Binding CopyCommand}"/>
+                    <MenuItem Header="Paste" Command="{Binding PasteCommand}"/>
+                    <MenuItem Header="Cut" Command="{Binding CutCommand}"/>
+                    <MenuItem Header="Open in Explorer" Command="{Binding OpenExplorerCommand}"/>
+                </ContextMenu>
+            </TreeView.ContextMenu>
+
+            <TreeView.Resources>
+                <Style TargetType="{x:Type TreeViewItem}">
+                    <Setter Property="KeyboardNavigation.TabNavigation" Value="Continue"/>
+                    <Setter Property="HeaderTemplate">
+                        <Setter.Value>
+                            <DataTemplate>
+                                <StackPanel Orientation="Horizontal">
+                                    <Image Width="20" Margin="3" 
+                                           Source="{Binding 
+                                                    RelativeSource={RelativeSource 
+                                                    Mode=FindAncestor, 
+                                                    AncestorType={x:Type TreeViewItem}},
+                                                    Path=Tag,
+                                                    Converter={StaticResource ImageConverter}
+                                        }" />
+                                    <TextBlock VerticalAlignment="Center" Text="{Binding}" />
+                                </StackPanel>
+                            </DataTemplate>
+                        </Setter.Value>
+                    </Setter>
+                </Style>
+            </TreeView.Resources>
+
+
+            <TreeView.ItemContainerStyle>
+                <Style TargetType ="{x:Type TreeViewItem}">
+                    <!-- We have to select the item which is right-clicked on -->
+                    <!--<EventSetter Event="TreeViewItem.DragOver" Handler="treeView_DragOver" />-->
+                    <!--<EventSetter Event="TreeViewItem.Drop" Handler="treeView_Drop" />-->
+                    <!--<EventSetter Event="TreeViewItem.MouseMove" Handler="treeView_MouseMove" />-->
+                </Style>
+            </TreeView.ItemContainerStyle>
+        </TreeView>
+    </Grid>
+</Window>
+
+
diff --git a/Sample Applications/WpfTreeView/MainWindow.xaml.cs b/Sample Applications/WpfTreeView/MainWindow.xaml.cs
new file mode 100644
index 000000000..a996b2b62
--- /dev/null
+++ b/Sample Applications/WpfTreeView/MainWindow.xaml.cs	
@@ -0,0 +1,1219 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+
+namespace WpfTreeView
+{
+    /// <summary>
+    /// Interaction logic for MainWindow.xaml
+    /// </summary>
+    public partial class MainWindow : Window
+    {
+        private Point _LastMousePos = new Point(0, 0);
+
+        #region Public Variables
+        private List<TreeViewItem> _VisibleItems = new List<TreeViewItem>();
+
+        public bool isCut = false;
+
+        /// <summary>
+        /// Store the Selected TreeView Item
+        /// </summary>
+        public Dictionary<TreeViewItem, string> selectedItems =
+            new Dictionary<TreeViewItem, string>();
+        private TreeViewItem lastSelectedItem = null;
+
+        /// <summary>
+        /// Dictionary for known files. If python is known, it assigns in logo as a python file.
+        /// </summary>
+        public IDictionary<string, ImageSource> KnownFiles { get; set; }
+
+        /// <summary>
+        /// Store the mouse button clicked last time
+        /// </summary>
+        Point _lastMouseDown;
+
+        /// <summary>
+        /// Item which has been dragged
+        /// </summary>
+        IEnumerable<TreeViewItem> draggedItem;
+
+        /// <summary>
+        /// Target location of the Item
+        /// </summary>
+        TreeViewItem _target;
+
+
+        #endregion
+
+        #region Copy Operation
+        public ICommand CopyCommand { get; set; }
+
+        public void ExecuteCopy(object sender)
+        {
+            // Clear Clipboard
+            Clipboard.Clear();
+
+            isCut = false;
+            var stringCollection = new StringCollection();
+
+            foreach (string path in selectedItems.Values)
+            {
+                stringCollection.Add(path);
+            }
+
+            if (stringCollection != null)
+            {
+                Clipboard.SetFileDropList(stringCollection);
+                (PasteCommand as RelayCommand).NotifyCanExecuteChanged(sender);
+            }
+        }
+
+        public bool CanCopy => selectedItems != null;
+        #endregion
+
+        #region Cut Operation
+
+        public ICommand CutCommand { get; set; }
+
+        public void ExecuteCut(object sender)
+        {
+            // Clear Clipboard
+            Clipboard.Clear();
+
+            isCut = true;
+            var stringCollection = new StringCollection();
+
+            foreach (string path in selectedItems.Values)
+            {
+                stringCollection.Add(path);
+            }
+
+            if (stringCollection != null)
+            {
+                Clipboard.SetFileDropList(stringCollection);
+                var temp = Clipboard.GetFileDropList();
+                (PasteCommand as RelayCommand).NotifyCanExecuteChanged(sender);
+            }
+        }
+
+        public bool CanCut => selectedItems != null;
+
+        #endregion
+
+        #region Paste Operation
+        public ICommand PasteCommand { get; set; }
+
+        /// <summary>
+        /// Execute Paste Operation
+        /// </summary>
+        /// <param name="sender"></param>
+        public void ExecutePaste(object sender)
+        {
+            // Get Tree View
+            var treeview = FolderView;
+
+            if (selectedItems.Count <= 0)
+                return;
+            try
+            {
+                foreach (var KV in selectedItems)
+                {
+                    var path = KV.Value;
+                    var item = KV.Key;
+                    var files = Clipboard.GetFileDropList();
+                    foreach (var file in files)
+                    {
+                        var newPath = Path.Combine(path, Path.GetFileName(file));
+                        var backupPath = Path.ChangeExtension(newPath, Path.GetExtension(newPath) + ".bak");
+
+                        if (File.Exists(newPath))
+                        {
+                            if (MessageBox.Show("The" + Path.GetFileName(newPath) + " already exist. Would you like to replace this file? ", "", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
+                            {
+                                // Replace the file
+                                File.Delete(newPath);
+                                File.Copy(file, newPath);
+                            }
+                        }
+                        else
+                        {
+                            if (isCut)
+                                File.Move(file, newPath);
+                            else
+                                File.Copy(file, newPath);
+                        }
+                    }
+                }
+            }
+            catch (Exception e) { MessageBox.Show("Paste Operation Failed : " + e.Message.ToString()); }
+
+            RefreshViews();
+        }
+        /// <summary>
+        /// If there are some files in clipboard and file count > 0 then allow paste operation
+        /// </summary>
+        public bool CanPaste => Clipboard.GetFileDropList() != null && Clipboard.GetFileDropList().Count > 0;
+        #endregion
+
+        #region Open Containing folder in Windows Explorer
+
+        /// <summary>
+        /// Command to open a file or folder containing folder
+        /// </summary>
+        public ICommand OpenExplorerCommand { get; set; }
+
+        /// <summary>
+        /// Execute command to open the file or folder containing folder
+        /// </summary>
+        /// <param name="sender"></param>
+        public void ExecuteOpeningExplorer(object sender)
+        {
+            if (selectedItems.Count != 1)
+                return;
+
+            // starts a new process of explorer.exe
+            Process.Start("explorer.exe", selectedItems.Values.FirstOrDefault().ToString());
+        }
+
+        /// <summary>
+        /// If only one is selected, then only open the folder otherwise not
+        /// </summary>
+        public bool CanOpenExplorer => selectedItems.Count == 1 && selectedItems.Values != null;
+
+        #endregion
+
+        #region Hard Refresh Command, recreates the treeview from scratch
+
+        /// <summary>
+        /// Hard refresh command
+        /// </summary>
+        public ICommand RefreshCommand { get; set; }
+
+        /// <summary>
+        /// Execute the hard refresh command
+        /// </summary>
+        /// <param name="sender"></param>
+        public void ExecuteRefresh(object sender)
+        {
+            FolderView.Items.Clear();
+            Window_Loaded(null, null);
+        }
+
+        /// <summary>
+        /// Can be refreshed without any condition
+        /// </summary>
+        public bool CanRefresh => true;
+
+        #endregion
+
+        #region Constructor
+        /// <summary>
+        /// Default Constructor
+        /// </summary>
+        public MainWindow()
+        {
+            // Copy and Paste command initialized
+            CopyCommand = new RelayCommand(ExecuteCopy, (_) => CanCopy);
+            PasteCommand = new RelayCommand(ExecutePaste, (_) => CanPaste);
+            CutCommand = new RelayCommand(ExecuteCut, (_) => CanCut);
+            OpenExplorerCommand = new RelayCommand(ExecuteOpeningExplorer, (_) => CanOpenExplorer);
+            RefreshCommand = new RelayCommand(ExecuteRefresh, (_) => CanRefresh);
+
+            InitializeComponent();
+
+            DataContext = this;
+
+            // Add known files such as .py into known Dictionary to recoginize that file
+            KnownFiles = new Dictionary<string, ImageSource>();
+            KnownFiles.Add(".py", Resources["PythonIcon"] as BitmapImage);
+            KnownFiles.Add(".cs", Resources["CSharpIcon"] as BitmapImage);
+            KnownFiles.Add(".c", Resources["CIcon"] as BitmapImage);
+            KnownFiles.Add(".cpp", Resources["CppIcon"] as BitmapImage);
+            KnownFiles.Add(".java", Resources["JavaIcon"] as BitmapImage);
+            KnownFiles.Add(".js", Resources["JavascriptIcon"] as BitmapImage);
+            KnownFiles.Add(".txt", Resources["TextIcon"] as BitmapImage);
+            KnownFiles.Add(".json", Resources["JsonIcon"] as BitmapImage);
+            KnownFiles.Add(".xlsx", Resources["XslxIcon"] as BitmapImage);
+            KnownFiles.Add(".pdf", Resources["PdfIcon"] as BitmapImage);
+            (Resources["ImageConverter"] as HeaderToImageConverter).KnownFiles = KnownFiles;
+        }
+        #endregion
+
+        #region On Loaded
+        /// <summary>
+        /// When the application first opens
+        /// </summary>
+        /// <param name="sender">Sender Object</param>
+        /// <param name="e">Sender Object event</param>
+        private void Window_Loaded(object sender, RoutedEventArgs e)
+        {
+            _VisibleItems.Clear();
+
+            // Get every logical drives on the machine
+            foreach (var drive in Directory.GetLogicalDrives())
+            {
+                // create a new item for it
+                var item = new TreeViewItem()
+                {
+                    // set the header
+                    Header = drive,
+                    // Set the full path
+                    Tag = drive
+                };
+                item.AllowDrop = true;
+                item.DragOver += MyTreeViewItem_DragOver;
+                item.MouseDown += MyTreeViewItem_MouseDown;
+                item.MouseMove += MyTreeViewItem_MouseMove;
+                item.Drop += MyTreeViewItem_Drop;
+
+
+                // Add a dummy item
+                item.Items.Add(null);
+
+                // Listen for the item being expanded
+                item.Expanded += Folder_Expanded;
+
+                // Add it to main tree view
+                FolderView.Items.Add(item);
+
+                _VisibleItems.Add(item);
+            }
+        }
+        #endregion
+
+        #region folder expanded
+        /// <summary>
+        /// When the folder is expanded
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        private void Folder_Expanded(object sender, RoutedEventArgs e)
+        {
+            #region Initial Checks
+            var item = (TreeViewItem)sender;
+
+            // if the item only contains the dummy data
+            if (item.Items.Count != 1 && item.Items[0] != null)
+                return;
+
+            // clear dummy data
+            item.Items.Clear();
+
+            // Get full path
+            var fullPath = (string)item.Tag;
+
+            var itemIdx = _VisibleItems.IndexOf(item);
+
+            #endregion
+
+            #region Get Directories
+
+            // Create a blank list
+            var directories = new ObservableCollection<string>();
+
+            // try and get directories from the folder
+            // ignoring any issues doing so
+            try
+            {
+                var dirs = Directory.GetDirectories(fullPath);
+
+                if (dirs.Length > 0)
+                    foreach (var dir in dirs)
+                        directories.Add(dir);
+            }
+            catch { }
+
+            foreach (var directoryPath in directories)
+            {
+                // Create Directory
+                var subItem = new TreeViewItem()
+                {
+                    // Set header as folder name
+                    Header = GetFileFolderName(directoryPath),
+                    // And tag as full path
+                    Tag = directoryPath
+                };
+                subItem.AllowDrop = true;
+
+                // Add dummy item so we can expand folder
+                subItem.Items.Add(null);
+                subItem.DragOver += MyTreeViewItem_DragOver;
+                subItem.MouseDown += MyTreeViewItem_MouseDown;
+                subItem.MouseMove += MyTreeViewItem_MouseMove;
+                subItem.Drop += MyTreeViewItem_Drop;
+
+                // Handle expanding
+                subItem.Expanded += Folder_Expanded;
+
+                // Add this item to parent
+                item.Items.Add(subItem);
+
+                _VisibleItems.Insert(++itemIdx, subItem);
+            }
+
+            #endregion
+
+            #region Get Files
+            // Create a blank list
+            var files = new ObservableCollection<string>();
+
+            // try and get files f1rom the folder
+            // ignoreing any issues doing so
+            try
+            {
+                var fs = Directory.GetFiles(fullPath);
+
+                if (fs.Length > 0)
+                    foreach (var f in fs)
+                        files.Add(f);
+            }
+            catch { }
+
+            foreach (var filePath in files)
+            {
+                // Create file
+                var subItem = new TreeViewItem()
+                {
+                    // Set header as file name
+                    Header = GetFileFolderName(filePath),
+                    // And tag as full path
+                    Tag = filePath
+                };
+                subItem.AllowDrop = true;
+                subItem.DragOver += MyTreeViewItem_DragOver;
+                subItem.MouseDown += MyTreeViewItem_MouseDown;
+                subItem.MouseMove += MyTreeViewItem_MouseMove;
+                subItem.Drop += MyTreeViewItem_Drop;
+
+                // Add this item to parent
+                item.Items.Add(subItem);
+
+                _VisibleItems.Insert(++itemIdx, subItem);
+            }
+
+
+            #endregion            
+        }
+
+        #endregion
+
+        #region Get File or Folder name
+        /// <summary>
+        /// Find the file or folder name from the full path
+        /// </summary>
+        /// <param name="path"></param>
+        /// <returns></returns>
+        public static string GetFileFolderName(string path)
+        {
+            // if we have no path, return empty
+            if (string.IsNullOrEmpty(path))
+                return string.Empty;
+
+            // Make all slashes back slashes
+            var normalizePath = path.Replace('/', '\\');
+
+            // find the last back slash in the path
+            var lastIndex = normalizePath.LastIndexOf('\\');
+
+            // if we don't find a backslash, return the path itself
+            if (lastIndex <= 0)
+                return path;
+
+            // return name after the last back slash
+            return path.Substring(lastIndex + 1);
+        }
+
+        #endregion
+
+        #region Folder View Selecting items for copy paste operations
+        /// <summary>
+        /// Triggers if selection is changed in the folder view
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        private void FolderView_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs<object> e)
+        {
+            (CopyCommand as RelayCommand).NotifyCanExecuteChanged(this);
+            (CutCommand as RelayCommand).NotifyCanExecuteChanged(this);
+
+            TreeViewItem treeViewItem = FolderView.SelectedItem as TreeViewItem;
+
+            if (treeViewItem == null)
+                return;
+
+            // prevent the WPF tree item selection 
+            treeViewItem.IsSelected = false;
+
+            treeViewItem.Focus();
+
+
+            #region Multi-Select with Control Key
+            // if the Ctrl key is pressed, then change the selected stated
+            if (Keyboard.Modifiers == ModifierKeys.Control)
+                if (Directory.Exists(treeViewItem.Tag.ToString()))
+                {
+                    // If it is directory, add all containing child items in the selection list
+                    foreach(var childItems in treeViewItem.Items)
+                    {
+                        ChangeSelectedState(childItems as TreeViewItem);
+                    }
+
+                }
+                else
+                {
+                    ChangeSelectedState(treeViewItem);
+                }
+
+
+            #endregion
+
+            #region If No modifier Key is selected
+            // If no special key is selected
+            if (Keyboard.Modifiers == ModifierKeys.None)
+            {
+                // create a list of tree view items for keep track of the selected files
+                List<TreeViewItem> selectedTreeViewItemList = new List<TreeViewItem>();
+
+                // for each treeview item in selected items, add all the items to the selection list
+                foreach (TreeViewItem treeViewItem1 in selectedItems.Keys)
+                {
+                    selectedTreeViewItemList.Add(treeViewItem1);
+                }
+                // Deselect the selected items
+                foreach (TreeViewItem treeViewItem1 in selectedTreeViewItemList)
+                {
+                    Deselect(treeViewItem1);
+                }
+
+                // only add the item which is selected to the list
+                ChangeSelectedState(treeViewItem);
+            }
+            #endregion
+
+            #region Multi-Select operation with Shift
+            // when the shift key is pressed
+            if (Keyboard.Modifiers == ModifierKeys.Shift)
+            {
+                // make sure the last selected item is not null
+                if (lastSelectedItem != null)
+                {
+                    bool select = false;
+                    bool foundBoth = false;
+                    var toSelect = new List<TreeViewItem>();
+
+                    // create a new stack of tree view items
+                    var stack = new Stack<TreeViewItem>();
+
+                    // push all the selected items in the stack
+                    foreach (TreeViewItem item in FolderView.Items)
+                        stack.Push(item);
+
+                    // Until there is no element left in the stack and 
+                    // both starting and ending elements are not found,
+                    // it remains in the while loop
+                    // If both of the elements are found, leave the while loop
+                    while (stack.Count > 0 && !foundBoth)
+                    {
+                        // take each item in the stack one by one
+                        var item = stack.Pop();
+
+                        // if either of the elements (starting or ending) is found
+                        if (item == lastSelectedItem || item == treeViewItem)
+                        {
+                            // set the select variable to true if
+                            // anyone of the element is founnd
+                            if (!select)
+                                select = true;
+                            // if both the elements are found, set foundboth to true
+                            else
+                                foundBoth = true;
+                        }
+
+                        // if anyone of the element is found, from that point on, add all the elements until it finds the other element
+                        if (select)
+                            toSelect.Add(item);
+
+                        // if there is still something in the list and the folder is expanded
+                        if (item.Items.Count > 0 && item.IsExpanded == true)
+                        {
+                            // Push all the elements to the stack
+                            foreach (TreeViewItem subItem in item.Items)
+                                stack.Push(subItem);
+                        }
+
+                    }
+
+                    foreach (var item in toSelect)
+                        Select(item);
+                }
+            }
+            #endregion
+
+        }
+
+        #region General Controls with Special keys
+
+        protected override void OnPreviewKeyDown(KeyEventArgs e)
+        {
+            base.OnKeyDown(e);
+
+            if (e.Key == Key.Up)
+            {
+
+                if (lastSelectedItem != null)
+                {
+
+                    var itemIdx = _VisibleItems.IndexOf(lastSelectedItem);
+                    var nextIdx = itemIdx - 1;
+                    if (nextIdx >= 0)
+                    {
+                        SelectOnly(_VisibleItems[nextIdx]);
+                    }
+                }
+
+                e.Handled = true;
+            }
+
+            if (e.Key == Key.Down)
+            {
+                if (lastSelectedItem != null)
+                {
+
+                    var itemIdx = _VisibleItems.IndexOf(lastSelectedItem);
+                    var nextIdx = itemIdx + 1;
+                    if (nextIdx < _VisibleItems.Count)
+                    {
+                        SelectOnly(_VisibleItems[nextIdx]);
+                    }
+                }
+
+                e.Handled = true;
+            }
+
+            if (e.Key == Key.Delete)
+            {
+                // if no item to delete selected, then return
+                if (selectedItems.Count <= 0)
+                    return;
+
+                // Ask if you really want to delete the selected items
+                if (MessageBox.Show("Do you really want to delete file/files ? ", "", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
+                {
+                    // if yes, delete all the selected items
+                    foreach (var path in selectedItems.Values)
+                    {
+                        File.Delete(path);
+                    }
+                }
+
+                // Refresh the view after deleting views
+                RefreshViews();
+            }
+        }
+
+        #endregion
+
+        /// <summary>
+        /// De-Select the tree View Item
+        /// </summary>
+        /// <param name="treeViewItem"></param>
+        void Deselect(TreeViewItem treeViewItem)
+        {
+            treeViewItem.Background = Brushes.White;// change background and foreground colors
+            treeViewItem.Foreground = Brushes.Black;
+            selectedItems.Remove(treeViewItem); // remove the item from the selected items set
+            lastSelectedItem = null;
+        }
+
+        void Select(TreeViewItem treeViewItem)
+        {
+            if (!selectedItems.ContainsKey(treeViewItem))
+            {
+                treeViewItem.Background = Brushes.RoyalBlue; // change background and foreground colors
+                treeViewItem.Foreground = Brushes.White;
+                selectedItems.Add(treeViewItem, treeViewItem.Tag.ToString()); // add the item to selected items
+            }
+
+            lastSelectedItem = treeViewItem;
+        }
+
+        void SelectOnly(TreeViewItem treeViewItem)
+        {
+
+
+            // if shift button is pressed, dont deselect
+            if (Keyboard.Modifiers == ModifierKeys.Shift)
+            {
+                Select(treeViewItem);
+            }
+            else
+            {
+                foreach (TreeViewItem item in selectedItems.Keys)
+                {
+                    Deselect(item);
+                }
+                Select(treeViewItem);
+            }
+        }
+
+        /// <summary>
+        /// changes the state of the tree item:
+        /// selects it if it has not been selected and
+        /// deselects it otherwise
+        /// </summary>
+        /// <param name="treeViewItem"></param>
+        void ChangeSelectedState(TreeViewItem treeViewItem)
+        {
+            if (!selectedItems.ContainsKey(treeViewItem))
+            { // select
+                Select(treeViewItem);
+            }
+            else
+            { // deselect
+                Deselect(treeViewItem);
+            }
+        }
+
+
+        /// <summary>
+        /// return true is control is pressed
+        /// </summary>
+
+        bool CtrlPressed => System.Windows.Input.Keyboard.IsKeyDown(Key.LeftCtrl);
+
+        bool ShiftPressed => System.Windows.Input.Keyboard.IsKeyDown(Key.LeftShift);
+        #endregion
+
+        #region Drag and Drop Utility functions
+        /// <summary>
+        /// This method get the position of the mouse cursor 
+        /// when the left mouse button is clicked
+        /// </summary>
+        /// <param name="sender">Sender Object</param>
+        /// <param name="e">Mouse Button Event Argument</param>
+        private void TreeView_MouseDown(object sender, MouseButtonEventArgs e)
+        {
+            if (e.ChangedButton == MouseButton.Left)
+            {
+                _lastMouseDown = e.GetPosition(FolderView);
+            }
+        }
+
+        /// <summary>
+        /// Once the left mouse button is click and moved, this method executes
+        /// </summary>
+        /// <param name="sender"> Object Sender</param>
+        /// <param name="e">Mouse Event Argument</param>
+        private void treeView_MouseMove(object sender, MouseEventArgs e)
+        {
+            try
+            {
+                // If left mouse is pressed
+                if (e.LeftButton == MouseButtonState.Pressed)
+                {
+                    // get the current position in the tree view
+                    Point currentPosition = e.GetPosition(FolderView);
+                    draggedItem = selectedItems.Keys.ToArray();
+
+                    // There is no item selected to drag, then return
+                    if (draggedItem == null)
+                        return;
+
+                    // if the mouse cursor is moved more than 10 pixels from the previous position,
+                    // it is considered that the item is dragged
+                    if ((Math.Abs(currentPosition.X - _lastMouseDown.X) > 10.0) ||
+                        (Math.Abs(currentPosition.Y - _lastMouseDown.Y) > 10.0))
+                    {
+                        foreach (TreeViewItem item in draggedItem)
+                        {
+                            if (selectedItems.Count != 0)
+                            {
+                                DragDropEffects finalDropEffects = DragDrop.DoDragDrop(FolderView, item.Header.ToString(), DragDropEffects.Move);
+
+                                if ((finalDropEffects == DragDropEffects.Move) && (_target != null))
+                                {
+                                    draggedItem = selectedItems.Keys.ToArray();
+
+                                    if (!item.Header.ToString().Equals(_target.Header.ToString()))
+                                    {
+                                        CopyItem(item, _target);
+                                    }
+                                    draggedItem = null;
+                                    _target = null;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            catch (Exception)
+            {
+                // In case exception happens, do nothing
+            }
+        }
+
+        private void MyTreeViewItem_DragOver(object sender, DragEventArgs e)
+        {
+            if(sender is TreeViewItem item)
+            {
+                if(e.Data.GetDataPresent(DataFormats.FileDrop))
+                {
+                    if(Keyboard.Modifiers == ModifierKeys.Control)
+                    {
+                        e.Effects = DragDropEffects.Copy;
+                    }
+                    else
+                    {
+                        e.Effects = DragDropEffects.Move;
+                    }
+                }
+                else
+                {
+                    e.Effects = DragDropEffects.None;
+                }
+            }
+            else
+            {
+                e.Effects = DragDropEffects.None;
+            }
+        }
+
+        private void MyTreeViewItem_MouseDown(object sender, MouseEventArgs e)
+        {
+            if (sender is TreeViewItem item)
+            {
+                _LastMousePos = e.GetPosition(item);
+            }
+        }
+
+        private void MyTreeViewItem_MouseMove(object sender, MouseEventArgs e)
+        {
+
+            if (sender is TreeViewItem item && e.LeftButton == MouseButtonState.Pressed)
+            {
+                var currPos = e.GetPosition(item);
+
+                var dx = currPos.X - _LastMousePos.X;
+                var dy = currPos.Y - _LastMousePos.Y;
+
+                if(Math.Sqrt(dx * dx * + dy * dy) > 20.0)
+                {
+                    DragDrop.DoDragDrop(item, new DataObject(DataFormats.FileDrop, new string[] { item.Tag as string }), DragDropEffects.All);
+                    Debug.WriteLine("DROP");
+                }
+            }
+
+        }
+
+        private void MyTreeViewItem_Drop(object sender, DragEventArgs e)
+        {
+            if (sender is TreeViewItem item && e.Data.GetDataPresent(DataFormats.FileDrop))
+            {
+                var targetDir = item.Tag as string;
+                var sourcePaths = e.Data.GetData(DataFormats.FileDrop) as string[];
+
+                while(targetDir != null && targetDir != "" && !Directory.Exists(targetDir))
+                {
+                    targetDir = Path.GetDirectoryName(targetDir);
+                }
+
+                if (sourcePaths == null || targetDir == null || targetDir == "")
+                    return;
+
+                foreach(var sourcePath in sourcePaths)
+                {
+                    var targetPath = Path.Combine(targetDir, Path.GetFileName(sourcePath));
+
+                    if (targetPath == sourcePath)
+                        continue;
+
+                    if(File.Exists(targetPath))
+                    {
+                        var ret = MessageBox.Show($"File {targetPath} already exists. Overwrite?", "File Exists", MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.No);
+                        if (ret == MessageBoxResult.No)
+                            continue;
+                    }
+
+                    if (Keyboard.Modifiers == ModifierKeys.Control)
+                    {
+                        File.Copy(sourcePath, targetPath, true);
+                    }
+                    else
+                    {
+                        File.Move(sourcePath, targetPath, true);
+                    }
+                }
+
+                //RefreshViews();  
+            }
+
+        }
+
+        /// <summary>
+        /// When the mouse cursor is dragged over some item
+        /// </summary>
+        /// <param name="sender">bject Sender </param>
+        /// <param name="e"> Drag Event </param>
+        private void treeView_DragOver(object sender, DragEventArgs e)
+        {
+            try
+            {
+                var myitem = sender as TreeViewItem;
+
+                // get current position of the cursor
+                Point currentPosition = e.GetPosition(FolderView);
+
+                // if the mouse cursor is moved more than 10 pixels from the previous position,
+                // it is considered that the item is dragged
+                if (Math.Abs(currentPosition.X - _lastMouseDown.X) > 10.0 ||
+                    Math.Abs(currentPosition.Y - _lastMouseDown.Y) > 10.0)
+                {
+                    // Verify that this is a valid drop and then store the drop target
+                    TreeViewItem item = GetNearestContainer(e.OriginalSource as UIElement);
+
+                    // If the dragged item list is null
+                    if (draggedItem == null)
+                        // TODO: Get the item as source and target which is outside the wpf app and copy the item and refresh the view
+
+                        return;
+
+                    foreach (TreeViewItem tvItem in draggedItem)
+                    {
+                        if (CheckDropTarget(tvItem, item))
+                        {
+                            e.Effects = DragDropEffects.Move;
+                        }
+                        else
+                        {
+                            e.Effects = DragDropEffects.None;
+                        }
+                    }
+
+                    // Clear Clipboard
+                    Clipboard.Clear();
+
+                    var stringCollection = new StringCollection();
+
+                    foreach (TreeViewItem tvItem in draggedItem)
+                    {
+                        stringCollection.Add(tvItem.Tag.ToString());
+                    }
+
+                    if (stringCollection != null)
+                    {
+                        Clipboard.SetFileDropList(stringCollection);
+                    }
+                }
+                e.Handled = true;
+
+                RefreshViews();
+            }
+            catch (Exception)
+            {
+                // In case of exception, do nothing
+            }
+        }
+
+        /// <summary>
+        /// This method is executed when the item is dropped over some other item
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        private void treeView_Drop(object sender, DragEventArgs e)
+        {
+            /*
+             * File dropping from file explorer to the tree view implemented and working
+             * TODO : Implementation of file dropping outside the wpf application
+             * */
+            try
+            {
+                e.Effects = DragDropEffects.None;
+
+                // Verify that this is a valid drop and then store the drop target
+                TreeViewItem TargetItem = GetNearestContainer(e.OriginalSource as UIElement);
+
+                if (TargetItem != null && draggedItem != null)
+                {
+                    _target = TargetItem;
+                    e.Effects = DragDropEffects.Move;
+                }
+
+                // Get Tree View
+                var treeview = FolderView;
+
+                // If the dragged item list is null, then check if the file to be dropped is there or not
+                if (draggedItem == null)
+                {
+                    if (e.Data.GetDataPresent(DataFormats.FileDrop))
+                    {
+                        // Get the files to drop which is coming from external source
+                        string[] files = (string[])e.Data.GetData(DataFormats.FileDrop);
+
+                        // foreach external files, modify the path string and copy the file to new location
+                        foreach (var f in files)
+                        {
+                            var newPath = Path.Combine(TargetItem.Tag.ToString(), Path.GetFileName(f));
+                            File.Copy(f, newPath);
+                        }
+
+                        // Refresh treeview to update changes
+                        RefreshViews();
+                        return;
+                    }
+
+                    return;
+                }
+
+                foreach (TreeViewItem tvItem in draggedItem)
+                {
+                    var files = Clipboard.GetFileDropList();
+                    foreach (var file in files)
+                    {
+                        var newPath = Path.Combine(_target.Tag.ToString(), Path.GetFileName(file));
+                        File.Move(file, newPath);
+                    }
+                }
+
+                RefreshViews();
+            }
+            catch (Exception)
+            {
+                // In case of exception, do nothing
+            }
+        }
+
+
+        private bool CheckDropTarget(TreeViewItem _sourceItem, TreeViewItem _targetItem)
+        {
+            // Check whether the target item is meeting the conditions
+            bool _isEqual = false;
+
+            if (!_sourceItem.Header.ToString().Equals(_targetItem.Header.ToString()))
+            {
+                _isEqual = true;
+            }
+            return _isEqual;
+        }
+
+
+        /// <summary>
+        /// Copy Item from source location to destination location
+        /// </summary>
+        /// <param name="draggedItem">Item which is dragged</param>
+        /// <param name="target">Destination Item</param>
+        private void CopyItem(TreeViewItem _sourceItem, TreeViewItem _targetItem)
+        {
+            // Shows dialog box to confirm dropping an item
+            if (MessageBox.Show("Would you like to drop " + _sourceItem.Header.ToString() +
+                " into " + _target.Header.ToString() + "", "", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
+            {
+                try
+                {
+                    // adding dragged TreeViewItem in target TreeViewItem
+                    addChild(_sourceItem, _target);
+
+                    // finding Parent TreeViewItem of dragged TreeViewItem
+                    TreeViewItem ParentItem = FindVisualParent<TreeViewItem>(_sourceItem);
+
+                    // If Parent is null then remove from TreeView else remove from Parent TreeView
+                    if (Parent == null)
+                    {
+                        FolderView.Items.Remove(_sourceItem);
+                    }
+                    else
+                    {
+                        ParentItem.Items.Remove(_sourceItem);
+                    }
+                }
+                catch (Exception) { }
+            }
+        }
+
+        /// <summary>
+        /// Add all the child items from source to target location 
+        /// </summary>
+        /// <param name="_sourceItem"> Source Items </param>
+        /// <param name="_targetItem"> Target Items </param>
+        private void addChild(TreeViewItem _sourceItem, TreeViewItem _targetItem)
+        {
+            // add item in target TreeViewItem
+            TreeViewItem item1 = new TreeViewItem();
+            item1.Header = _sourceItem.Header;
+            _targetItem.Items.Add(item1);
+            foreach (TreeViewItem item in _sourceItem.Items)
+            {
+                addChild(item, item1);
+            }
+        }
+
+        /// <summary>
+        /// Find the Parent of the Child Item in UI
+        /// </summary>
+        /// <typeparam name="TObject"> UIElement as Object</typeparam>
+        /// <param name="child">Child item</param>
+        /// <returns>Parent item</returns>
+        private TObject FindVisualParent<TObject>(UIElement child) where TObject : UIElement
+        {
+            if (child == null)
+            {
+                return null;
+            }
+
+            // get the parent item of the child element as UIElement
+            UIElement parent = VisualTreeHelper.GetParent(child) as UIElement;
+
+            while (parent != null)
+            {
+                if (parent is TObject found)
+                {
+                    return found;
+                }
+                else
+                {
+                    parent = VisualTreeHelper.GetParent(parent) as UIElement;
+                }
+            }
+
+            return null;
+        }
+
+        private TreeViewItem GetNearestContainer(UIElement element)
+        {
+            // Walk up the element tree to the nearest tree view item
+            TreeViewItem container = element as TreeViewItem;
+            while (container == null && element != null)
+            {
+                element = VisualTreeHelper.GetParent(element) as UIElement;
+                container = element as TreeViewItem;
+            }
+
+            return container;
+        }
+
+        #endregion
+
+        #region Refreshing Views
+        /// <summary>
+        /// Refresh and Update the View
+        /// </summary>
+        private void RefreshViews()
+        {
+            foreach (TreeViewItem item in FolderView.Items)
+                RefreshSubtree(item);
+        }
+
+        /// <summary>
+        /// Get the current status of the each of the sub-item to know which item is expanded and which item is not
+        /// </summary>
+        /// <param name="item">The item or subitem</param>
+        /// <param name="expansionState">If the item is expanded, then return true else false</param>
+        private void CaptureExpansionState(TreeViewItem item, Dictionary<string, bool> expansionState)
+        {
+            // return if there is no item which means it is not expanded or not expandable
+            if (item == null || item.Items.Count == 0)
+                return;
+
+            // get the path of the item: file 
+            var path = item.Tag as string;
+
+            // added the path to the expansion list
+            expansionState.Add(path, item.IsExpanded);
+
+            // for each item in treeview list
+            foreach (TreeViewItem subItem in item.Items)
+                // repeat the same steps for each of the sub-items
+                CaptureExpansionState(subItem, expansionState);
+
+        }
+
+        /// <summary>
+        /// Restore the expanded items
+        /// </summary>
+        /// <param name="item">the treeview item or subitems</param>
+        /// <param name="expansionState">If true then item or sub-item is expanded otherwise not expanded</param>
+        private void RestoreExpansionState(TreeViewItem item, Dictionary<string, bool> expansionState)
+        {
+            // get the path of the item: file
+            var path = item.Tag as string;
+
+            // retrieve the items which are expanded
+            var ret = expansionState.TryGetValue(path, out bool isExpanded);
+
+            // if item to retrieve exists
+            if (ret)
+            {
+                // set the isExpanded flag to the current state
+                item.IsExpanded = isExpanded;
+            }
+        }
+
+        /// <summary>
+        /// Refresh the items and the subitems for each view
+        /// </summary>
+        /// <param name="item">The Treeview item or sub-item</param>
+        private void RefreshSubtree(TreeViewItem item)
+        {
+            // if the item is not expanded or the item is not expandable such as file, then return
+            if (!item.IsExpanded || item.Items.Count == 0)
+                return;
+
+            // Store the expansion state of the treeview items or sub-items
+            var expansionState = new Dictionary<string, bool>();
+
+            // Get the expansion state of the Treeview item or sub-items
+            CaptureExpansionState(item, expansionState);
+
+            // set isexpanded flag to false as the initial state
+            item.IsExpanded = false;
+
+            // clear all the tree view items or sub-items
+            item.Items.Clear();
+
+            // Add a null item to the view to show that it is expandable
+            item.Items.Add(null);
+
+            // Set the isExpanded flag to true
+            item.IsExpanded = true;
+
+            // initialize the stack to store tree view items temporarily
+            var stack = new Stack<TreeViewItem>();
+
+            // foreach subitems in the list of treeview items
+            foreach (TreeViewItem subItem in item.Items)
+                // store the item into stack
+                stack.Push(subItem);
+
+            // as long as there are items in stack, keep running
+            while (stack.Count > 0)
+            {
+                // get each of the subitems stored in the stack
+                var subItem = stack.Pop();
+
+                // Restore it's expansion state
+                RestoreExpansionState(subItem, expansionState);
+
+                // if the subitem is expanded
+                if (subItem.IsExpanded)
+                {
+                    // for each subitems within subitems in the treeview items  
+                    foreach (TreeViewItem subSubItem in subItem.Items)
+                        // add the items to the stack
+                        stack.Push(subSubItem);
+                }
+            }
+        }
+
+        #endregion
+
+    }
+}
diff --git a/Sample Applications/WpfTreeView/Properties/Resources.Designer.cs b/Sample Applications/WpfTreeView/Properties/Resources.Designer.cs
new file mode 100644
index 000000000..280e78e74
--- /dev/null
+++ b/Sample Applications/WpfTreeView/Properties/Resources.Designer.cs	
@@ -0,0 +1,71 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:2.0.50727.3053
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace WpfTreeView.Properties
+{
+
+
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "2.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class Resources
+    {
+
+        private static global::System.Resources.ResourceManager resourceMan;
+
+        private static global::System.Globalization.CultureInfo resourceCulture;
+
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal Resources()
+        {
+        }
+
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager
+        {
+            get
+            {
+                if ((resourceMan == null))
+                {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("WpfTreeView.Properties.Resources", typeof(Resources).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture
+        {
+            get
+            {
+                return resourceCulture;
+            }
+            set
+            {
+                resourceCulture = value;
+            }
+        }
+    }
+}
diff --git a/Sample Applications/WpfTreeView/Properties/Resources.resx b/Sample Applications/WpfTreeView/Properties/Resources.resx
new file mode 100644
index 000000000..af7dbebba
--- /dev/null
+++ b/Sample Applications/WpfTreeView/Properties/Resources.resx	
@@ -0,0 +1,117 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>
\ No newline at end of file
diff --git a/Sample Applications/WpfTreeView/Properties/Settings.Designer.cs b/Sample Applications/WpfTreeView/Properties/Settings.Designer.cs
new file mode 100644
index 000000000..d1947067b
--- /dev/null
+++ b/Sample Applications/WpfTreeView/Properties/Settings.Designer.cs	
@@ -0,0 +1,30 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:2.0.50727.3053
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace WpfTreeView.Properties
+{
+
+
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "9.0.0.0")]
+    internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase
+    {
+
+        private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings())));
+
+        public static Settings Default
+        {
+            get
+            {
+                return defaultInstance;
+            }
+        }
+    }
+}
diff --git a/Sample Applications/WpfTreeView/Properties/Settings.settings b/Sample Applications/WpfTreeView/Properties/Settings.settings
new file mode 100644
index 000000000..033d7a5e9
--- /dev/null
+++ b/Sample Applications/WpfTreeView/Properties/Settings.settings	
@@ -0,0 +1,7 @@
+<?xml version='1.0' encoding='utf-8'?>
+<SettingsFile xmlns="uri:settings" CurrentProfile="(Default)">
+  <Profiles>
+    <Profile Name="(Default)" />
+  </Profiles>
+  <Settings />
+</SettingsFile>
\ No newline at end of file
diff --git a/Sample Applications/WpfTreeView/RelayCommand.cs b/Sample Applications/WpfTreeView/RelayCommand.cs
new file mode 100644
index 000000000..6a6a933eb
--- /dev/null
+++ b/Sample Applications/WpfTreeView/RelayCommand.cs	
@@ -0,0 +1,78 @@
+using System;
+using System.Windows.Input;
+
+namespace WpfTreeView
+{
+    public class RelayCommand : ICommand
+    {
+        public static readonly RelayCommand None = new RelayCommand((_) => { }, (_) => false);
+
+        /// <summary>
+        /// Action that gets executed when the command is triggered.
+        /// </summary>
+        private readonly Action<object> _Execute;
+
+        /// <summary>
+        /// Predicate that is evaluated to determine if the command 
+        /// </summary>
+        private readonly Predicate<object> _CanExecute;
+
+        private event EventHandler _CanExecuteChanged;
+
+        /// <summary>
+        /// Creates a relay command 
+        /// </summary>
+        /// <param name="execute"></param>
+        public RelayCommand(Action<object> execute) : this(execute, null) { }
+        public RelayCommand(Action<object> execute, Predicate<object> canExecute)
+        {
+            if (execute == null)
+                throw new ArgumentNullException("execute");
+
+            _Execute = execute;
+            _CanExecute = canExecute;
+        }
+
+        /// <summary>
+        /// Evaluates if the command can execute.
+        /// </summary>
+        /// <param name="parameter"></param>
+        /// <returns></returns>
+        public bool CanExecute(object parameter)
+        {
+            return _CanExecute == null ? true : _CanExecute.Invoke(parameter);
+        }
+
+        public event EventHandler CanExecuteChanged
+        {
+            add
+            {
+                _CanExecuteChanged += value;
+                CommandManager.RequerySuggested += value;
+            }
+            remove
+            {
+                _CanExecuteChanged -= value;
+                CommandManager.RequerySuggested -= value;
+            }
+        }
+
+        /// <summary>
+        /// Executes the command.
+        /// </summary>
+        /// <param name="parameter"></param>
+        public void Execute(object parameter)
+        {
+            _Execute?.Invoke(parameter);
+        }
+
+        /// <summary>
+        /// Notifies listeners that the can execute predicate has changed.
+        /// </summary>
+        /// <param name="sender"></param>
+        public void NotifyCanExecuteChanged(object sender)
+        {
+            _CanExecuteChanged?.Invoke(sender, EventArgs.Empty);
+        }
+    }
+}
diff --git a/Sample Applications/WpfTreeView/Window1.xaml b/Sample Applications/WpfTreeView/Window1.xaml
new file mode 100644
index 000000000..4c1cb4116
--- /dev/null
+++ b/Sample Applications/WpfTreeView/Window1.xaml	
@@ -0,0 +1,44 @@
+<Window x:Class="WpfTreeView.Window1"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    Title="Drag and Drop Winodow" Height="376" Width="434">
+    <Grid>
+        <TreeView Name="tvParameters" AllowDrop="True" Background="PowderBlue" Foreground="DarkBlue" FontSize="15">
+            <TreeViewItem Header="1" >
+                <TreeViewItem Header="1.1" >
+                    <TreeViewItem Header="1.1.1" >
+
+                    </TreeViewItem>
+                </TreeViewItem>
+            </TreeViewItem>
+            <TreeViewItem Header="2" >
+                <TreeViewItem Header="2.1" >
+                    <TreeViewItem Header="2.1.1" >
+                        <TreeViewItem Header="2.1.1.1" >
+                            <TreeViewItem Header="2.1.1.1.1" >
+                            </TreeViewItem>
+                        </TreeViewItem>
+                    </TreeViewItem>
+                </TreeViewItem>
+            <TreeViewItem Header="2.2" >
+                    <TreeViewItem Header="2.2.1" AllowDrop="True">
+                    </TreeViewItem>
+                </TreeViewItem>
+            </TreeViewItem>
+            <TreeView.ItemContainerStyle>
+                <Style TargetType="{x:Type TreeViewItem}">
+                    <!-- We have to select the item which is right-clicked on -->
+                    <!--<EventSetter Event="TreeViewItem.PreviewMouseRightButtonDown" Handler="TreeViewItem_PreviewMouseRightButtonDown"/>-->
+                    <EventSetter Event="TreeViewItem.DragOver" Handler="treeView_DragOver"/>
+                    <EventSetter Event="TreeViewItem.Drop" Handler="treeView_Drop"/>
+                    <EventSetter Event="TreeViewItem.MouseMove" Handler="treeView_MouseMove"/>
+
+
+
+
+                </Style>
+
+            </TreeView.ItemContainerStyle>
+        </TreeView>
+    </Grid>
+</Window>
diff --git a/Sample Applications/WpfTreeView/Window1.xaml.cs b/Sample Applications/WpfTreeView/Window1.xaml.cs
new file mode 100644
index 000000000..72fc0eba6
--- /dev/null
+++ b/Sample Applications/WpfTreeView/Window1.xaml.cs	
@@ -0,0 +1,214 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Windows;
+using System.Windows.Controls;
+using System.Windows.Data;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+using System.Windows.Navigation;
+using System.Windows.Shapes;
+
+namespace WpfTreeView
+{
+    /// <summary>
+    /// Interaction logic for Window1.xaml
+    /// </summary>
+    public partial class Window1 : Window
+    {
+        Point _lastMouseDown;
+        TreeViewItem draggedItem, _target;
+        public Window1()
+        {
+            InitializeComponent();
+        }
+
+        private void TreeView_MouseDown(object sender, MouseButtonEventArgs e)
+        {
+            if (e.ChangedButton == MouseButton.Left)
+            {
+                _lastMouseDown = e.GetPosition(tvParameters);
+            }
+
+        }
+        private void treeView_MouseMove(object sender, MouseEventArgs e)
+        {
+            try
+            {
+                if (e.LeftButton == MouseButtonState.Pressed)
+                {
+                    Point currentPosition = e.GetPosition(tvParameters);
+
+                    
+                    if ((Math.Abs(currentPosition.X - _lastMouseDown.X) > 10.0) ||
+                        (Math.Abs(currentPosition.Y - _lastMouseDown.Y) > 10.0))
+                    {
+                        draggedItem = (TreeViewItem)tvParameters.SelectedItem;
+                        if (draggedItem != null)
+                        {
+                            DragDropEffects finalDropEffect = DragDrop.DoDragDrop(tvParameters, tvParameters.SelectedValue,
+                                DragDropEffects.Move);
+                            //Checking target is not null and item is dragging(moving)
+                            if ((finalDropEffect == DragDropEffects.Move) && (_target != null))
+                            {
+                                // A Move drop was accepted
+                                if (!draggedItem.Header.ToString().Equals(_target.Header.ToString()))
+                                {
+                                    CopyItem(draggedItem, _target);
+                                    _target = null;
+                                    draggedItem = null;
+                                }       
+
+                            }
+                        }
+                    }
+                }
+            }
+            catch (Exception)
+            {
+            }
+        }
+        private void treeView_DragOver(object sender, DragEventArgs e)
+        {
+            try
+            {
+                   
+                Point currentPosition = e.GetPosition(tvParameters);
+
+              
+                if ((Math.Abs(currentPosition.X - _lastMouseDown.X) > 10.0) ||
+                    (Math.Abs(currentPosition.Y - _lastMouseDown.Y) > 10.0))
+                {
+                    // Verify that this is a valid drop and then store the drop target
+                    TreeViewItem item = GetNearestContainer(e.OriginalSource as UIElement);
+                    if (CheckDropTarget(draggedItem, item))
+                    {
+                        e.Effects = DragDropEffects.Move;
+                    }
+                    else
+                    {
+                        e.Effects = DragDropEffects.None;
+                    }
+                }
+                e.Handled = true;
+            }
+            catch (Exception)
+            {
+            }
+        }
+        private void treeView_Drop(object sender, DragEventArgs e)
+        {
+            try
+            {
+                e.Effects = DragDropEffects.None;
+                e.Handled = true;
+
+                // Verify that this is a valid drop and then store the drop target
+                TreeViewItem TargetItem = GetNearestContainer(e.OriginalSource as UIElement);
+                if (TargetItem != null && draggedItem != null )
+                {
+                    _target = TargetItem;
+                    e.Effects = DragDropEffects.Move;
+
+                }
+            }
+            catch (Exception)
+            {
+            }
+
+
+
+        }
+        private bool CheckDropTarget(TreeViewItem _sourceItem, TreeViewItem _targetItem)
+        {
+            //Check whether the target item is meeting your condition
+            bool _isEqual = false;
+            if (!_sourceItem.Header.ToString().Equals(_targetItem.Header.ToString()))
+            {
+                _isEqual = true;
+            }
+            return _isEqual;
+
+        }
+        private void CopyItem(TreeViewItem _sourceItem, TreeViewItem _targetItem)
+        {
+
+            //Asking user wether he want to drop the dragged TreeViewItem here or not
+            if (MessageBox.Show("Would you like to drop " + _sourceItem.Header.ToString() + " into " + _targetItem.Header.ToString() + "", "", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
+            {
+                try
+                {
+                    //adding dragged TreeViewItem in target TreeViewItem
+                    addChild(_sourceItem, _targetItem);
+
+                    //finding Parent TreeViewItem of dragged TreeViewItem 
+                    TreeViewItem ParentItem = FindVisualParent<TreeViewItem>(_sourceItem);
+                    // if parent is null then remove from TreeView else remove from Parent TreeViewItem
+                    if (ParentItem == null)
+                    {
+                        tvParameters.Items.Remove(_sourceItem);
+                    }
+                    else
+                    {                        
+                        ParentItem.Items.Remove(_sourceItem);
+                    }
+                }
+                catch
+                {
+
+                }
+            }
+
+        }
+        public void addChild(TreeViewItem _sourceItem,TreeViewItem _targetItem)
+        {
+            // add item in target TreeViewItem 
+            TreeViewItem item1 = new TreeViewItem();
+            item1.Header = _sourceItem.Header;
+            _targetItem.Items.Add(item1);    
+            foreach (TreeViewItem item in _sourceItem.Items)
+            {
+                addChild(item, item1);               
+            }
+        }
+        static TObject FindVisualParent<TObject>(UIElement child) where TObject : UIElement
+        {
+            if (child == null)
+            {
+                return null;
+            }
+
+            UIElement parent = VisualTreeHelper.GetParent(child) as UIElement;
+
+            while (parent != null)
+            {
+                TObject found = parent as TObject;
+                if (found != null)
+                {
+                    return found;
+                }
+                else
+                {
+                    parent = VisualTreeHelper.GetParent(parent) as UIElement;
+                }
+            }
+
+            return null;
+        }
+        private TreeViewItem GetNearestContainer(UIElement element)
+        {
+            // Walk up the element tree to the nearest tree view item.
+            TreeViewItem container = element as TreeViewItem;
+            while ((container == null) && (element != null))
+            {
+                element = VisualTreeHelper.GetParent(element) as UIElement;
+                container = element as TreeViewItem;
+            }
+            return container;
+        }
+
+    }
+}
diff --git a/Sample Applications/WpfTreeView/WpfTreeView.csproj b/Sample Applications/WpfTreeView/WpfTreeView.csproj
new file mode 100644
index 000000000..c45b9547b
--- /dev/null
+++ b/Sample Applications/WpfTreeView/WpfTreeView.csproj	
@@ -0,0 +1,44 @@
+<Project Sdk="Microsoft.NET.Sdk.WindowsDesktop">
+
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+	<GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <UseWPF>true</UseWPF>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <None Remove="Images\c.png" />
+    <None Remove="Images\cpp.png" />
+    <None Remove="Images\csharp.png" />
+    <None Remove="Images\drive.png" />
+    <None Remove="Images\file.png" />
+    <None Remove="Images\folder-closed.png" />
+    <None Remove="Images\folder-open.png" />
+    <None Remove="Images\java.png" />
+    <None Remove="Images\javascript.png" />
+    <None Remove="Images\json.png" />
+    <None Remove="Images\pdf.png" />
+    <None Remove="Images\python.png" />
+    <None Remove="Images\txt.png" />
+    <None Remove="Images\xlsx.png" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Resource Include="Images\c.png" />
+    <Resource Include="Images\cpp.png" />
+    <Resource Include="Images\csharp.png" />
+    <Resource Include="Images\drive.png" />
+    <Resource Include="Images\file.png" />
+    <Resource Include="Images\folder-closed.png" />
+    <Resource Include="Images\folder-open.png" />
+    <Resource Include="Images\java.png" />
+    <Resource Include="Images\javascript.png" />
+    <Resource Include="Images\json.png" />
+    <Resource Include="Images\pdf.png" />
+    <Resource Include="Images\python.png" />
+    <Resource Include="Images\txt.png" />
+    <Resource Include="Images\xlsx.png" />
+  </ItemGroup>
+
+</Project>