MainWindow.xaml.cs

using Microsoft.VisualBasic.FileIO;
using System;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Windows;
using System.Windows.Input;
using System.Windows.Interop;
using System.Windows.Media;
using System.Windows.Media.Imaging;

namespace GarbageCollector
{
    public partial class MainWindow : Window
    {
        private readonly string desktopPath = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
        public ObservableCollection<FileItem> Files { get; set; } = new ObservableCollection<FileItem>();

        public MainWindow()
        {
            InitializeComponent();
            LoadFiles();
        }

        private void LoadFiles()
        {
            Files.Clear();

            // Add folders
            foreach (var dir in Directory.GetDirectories(desktopPath))
            {
                Files.Add(new FileItem
                {
                    Name = Path.GetFileName(dir),
                    FullPath = dir,
                    Icon = IconHelper.GetIcon(dir, true),
                    IsFolder = true
                });
            }

            // Add files
            foreach (var file in Directory.GetFiles(desktopPath))
            {
                Files.Add(new FileItem
                {
                    Name = Path.GetFileName(file),
                    FullPath = file,
                    Icon = IconHelper.GetIcon(file, false),
                    IsFolder = false
                });
            }

            FileList.ItemsSource = Files;
        }

        private void DeleteSelected_Click(object sender, RoutedEventArgs e)
        {
            var selected = Files.Where(f => f.IsChecked).ToList();
            if (!selected.Any())
            {
                MessageBox.Show("No items selected.", "GarbageCollector", MessageBoxButton.OK, MessageBoxImage.Information);
                return;
            }

            // CONFIRMATION
            var result = MessageBox.Show(
                $"Are you sure you want to delete {selected.Count} selected item(s)? They will be sent to the Recycle Bin.",
                "Confirm Delete",
                MessageBoxButton.YesNo,
                MessageBoxImage.Warning);

            if (result != MessageBoxResult.Yes) return;

            foreach (var f in selected)
            {
                try
                {
                    if (f.IsFolder)
                    {
                        Microsoft.VisualBasic.FileIO.FileSystem.DeleteDirectory(f.FullPath,
                            Microsoft.VisualBasic.FileIO.UIOption.OnlyErrorDialogs,
                            Microsoft.VisualBasic.FileIO.RecycleOption.SendToRecycleBin);
                    }
                    else
                    {
                        Microsoft.VisualBasic.FileIO.FileSystem.DeleteFile(f.FullPath,
                            Microsoft.VisualBasic.FileIO.UIOption.OnlyErrorDialogs,
                            Microsoft.VisualBasic.FileIO.RecycleOption.SendToRecycleBin);
                    }
                }
                catch (Exception ex)
                {
                    MessageBox.Show($"Error deleting {f.Name}: {ex.Message}", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                }
            }

            LoadFiles();
        }


        private void OrganizeByType_Click(object sender, RoutedEventArgs e)
        {
            // CONFIRMATION
            var result = MessageBox.Show(
                "Are you sure you want to organize your desktop files into folders by type?",
                "Confirm Organize",
                MessageBoxButton.YesNo,
                MessageBoxImage.Question);

            if (result != MessageBoxResult.Yes) return;

            foreach (var file in Directory.GetFiles(desktopPath))
            {
                string ext = Path.GetExtension(file).Trim('.').ToUpper();
                if (string.IsNullOrEmpty(ext)) ext = "OTHERS";

                string folder = Path.Combine(desktopPath, ext);
                Directory.CreateDirectory(folder);

                string destPath = Path.Combine(folder, Path.GetFileName(file));
                try
                {
                    if (!File.Exists(destPath))
                        File.Move(file, destPath);
                }
                catch (Exception ex)
                {
                    MessageBox.Show($"Error moving {file}: {ex.Message}");
                }
            }
            LoadFiles();
        }


        private void Refresh_Click(object sender, RoutedEventArgs e) => LoadFiles();

        private void FileList_MouseDoubleClick(object sender, MouseButtonEventArgs e)
        {
            if (FileList.SelectedItem is FileItem item)
            {
                try
                {
                    var psi = new ProcessStartInfo
                    {
                        FileName = item.FullPath,
                        UseShellExecute = true
                    };
                    Process.Start(psi);
                }
                catch (Exception ex)
                {
                    MessageBox.Show($"Cannot open {item.Name}: {ex.Message}");
                }
            }
        }

        private void About_Click(object sender, RoutedEventArgs e)
        {
            MessageBox.Show(
                    "GarbageCollector\n\nA simple desktop organizer.\n\nCreated by mikeph_ 2025\nhttps://github.com/mikeph52\n\nVersion Alpha Testing",
                    "About GarbageCollector",
            MessageBoxButton.OK,
            MessageBoxImage.Information);
        }
       
    }

    // ========== FileItem ========== 
    public class FileItem
    {
        public string Name { get; set; }
        public string FullPath { get; set; }
        public bool IsFolder { get; set; }
        public bool IsChecked { get; set; }
        public ImageSource Icon { get; set; }
    }

    // ========== IconHelper ========== 
    internal static class IconHelper
    {
        private const uint SHGFI_ICON = 0x000000100;
        private const uint SHGFI_SMALLICON = 0x000000001;
        private const uint FILE_ATTRIBUTE_DIRECTORY = 0x10;
        private const uint FILE_ATTRIBUTE_NORMAL = 0x80;

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
        private struct SHFILEINFO
        {
            public IntPtr hIcon;
            public int iIcon;
            public uint dwAttributes;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
            public string szDisplayName;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 80)]
            public string szTypeName;
        }

        [DllImport("shell32.dll", CharSet = CharSet.Auto)]
        private static extern IntPtr SHGetFileInfo(string pszPath, uint dwFileAttributes, ref SHFILEINFO psfi, uint cbFileInfo, uint uFlags);

        [DllImport("user32.dll", SetLastError = true)]
        private static extern bool DestroyIcon(IntPtr hIcon);

        public static ImageSource GetIcon(string path, bool isFolder)
        {
            try
            {
                SHFILEINFO shinfo = new SHFILEINFO();
                uint flags = SHGFI_ICON | SHGFI_SMALLICON;
                uint attrs = isFolder ? FILE_ATTRIBUTE_DIRECTORY : FILE_ATTRIBUTE_NORMAL;

                SHGetFileInfo(path, attrs, ref shinfo, (uint)Marshal.SizeOf(shinfo), flags);
                if (shinfo.hIcon != IntPtr.Zero)
                {
                    var img = Imaging.CreateBitmapSourceFromHIcon(
                        shinfo.hIcon,
                        Int32Rect.Empty,
                        BitmapSizeOptions.FromWidthAndHeight(16, 16));
                    img.Freeze();
                    DestroyIcon(shinfo.hIcon);
                    return img;
                }
            }
            catch
            {
                // fallback: no icon
            }
            return null;
        }
    }
}