BetterFolderBrowser

https://github.com/willy-kimura/betterfolderbrowser
Admin
BetterFolderBrowser is a .NET component library that provides developers with an enhanced...
Tokens:6,089
Snippets:18
Trust Score:9.2
License:MIT
Update:11 months ago
Show doc for...
Tokens:
Raw
### Complete Windows Forms Example with BetterFolderBrowser in C#

Source: https://context7.com/willy-kimura/betterfolderbrowser/llms.txt

This C# code provides a comprehensive example of a Windows Forms application utilizing the BetterFolderBrowser. It initializes the UI, configures the folder browser with user-defined settings (title, root folder, multiselect), handles user interactions for selecting folders and setting the root, and displays the selected paths. Dependencies include System.Windows.Forms and WK.Libraries.BetterFolderBrowserNS.

```csharp
using System;
using System.Windows.Forms;
using WK.Libraries.BetterFolderBrowserNS;

namespace CompleteExample
{
    public partial class FolderManagerForm : Form
    {
        private BetterFolderBrowser folderBrowser;
        private TextBox txtDialogTitle;
        private TextBox txtRootFolder;
        private CheckBox chkAllowMultiselect;
        private Button btnSelectFolder;
        private Button btnChooseRoot;
        private Button btnReset;
        private ListBox lstSelectedFolders;
        private Label lblStatus;

        public FolderManagerForm()
        {
            InitializeComponent();

            // Initialize component
            folderBrowser = new BetterFolderBrowser();

            // Set default values
            txtDialogTitle.Text = "Please select a folder...";
            txtRootFolder.Text = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
            chkAllowMultiselect.Checked = false;
        }

        private void InitializeComponent()
        {
            this.Text = "Better Folder Browser Demo";
            this.Size = new System.Drawing.Size(600, 500);

            // Create controls
            txtDialogTitle = new TextBox { Location = new System.Drawing.Point(20, 20), Width = 400 };
            txtRootFolder = new TextBox { Location = new System.Drawing.Point(20, 60), Width = 400 };
            chkAllowMultiselect = new CheckBox { Location = new System.Drawing.Point(20, 100), Text = "Allow Multi-Select" };
            btnSelectFolder = new Button { Location = new System.Drawing.Point(20, 140), Text = "Select Folder(s)", Width = 120 };
            btnChooseRoot = new Button { Location = new System.Drawing.Point(440, 58), Text = "...", Width = 30 };
            btnReset = new Button { Location = new System.Drawing.Point(150, 140), Text = "Reset", Width = 120 };
            lstSelectedFolders = new ListBox { Location = new System.Drawing.Point(20, 180), Size = new System.Drawing.Size(540, 250) };
            lblStatus = new Label { Location = new System.Drawing.Point(20, 440), Text = "No folders selected", AutoSize = true };

            // Wire up events
            btnSelectFolder.Click += btnSelectFolder_Click;
            btnChooseRoot.Click += btnChooseRoot_Click;
            btnReset.Click += btnReset_Click;
            chkAllowMultiselect.CheckedChanged += chkAllowMultiselect_CheckedChanged;

            // Add to form
            this.Controls.AddRange(new Control[]
            {
                txtDialogTitle, txtRootFolder, chkAllowMultiselect,
                btnSelectFolder, btnChooseRoot, btnReset,
                lstSelectedFolders, lblStatus
            });
        }

        private void btnSelectFolder_Click(object sender, EventArgs e)
        {
            // Configure from UI controls
            folderBrowser.Title = txtDialogTitle.Text;
            folderBrowser.RootFolder = txtRootFolder.Text;
            folderBrowser.Multiselect = chkAllowMultiselect.Checked;

            // Show dialog (modal)
            if (folderBrowser.ShowDialog(this) == DialogResult.OK)
            {
                lblStatus.Visible = false;
                lstSelectedFolders.Items.Clear();

                // Add all selected folders to list
                lstSelectedFolders.Items.AddRange(folderBrowser.SelectedPaths);

                // Log results
                Console.WriteLine($"Dialog returned OK. Selected {folderBrowser.SelectedPaths.Length} folder(s):");
                foreach (string path in folderBrowser.SelectedPaths)
                {
                    Console.WriteLine($"  - {path}");
                }
            }
            else
            {
                lblStatus.Text = "Selection cancelled";
                lblStatus.Visible = true;
                Console.WriteLine("Dialog cancelled by user");
            }
        }

        private void btnChooseRoot_Click(object sender, EventArgs e)
        {
            // Use separate instance for root selection
            BetterFolderBrowser rootSelector = new BetterFolderBrowser();
            rootSelector.Title = "Choose any folder as the root folder...";
            rootSelector.RootFolder = @"C:\";
            rootSelector.Multiselect = false;

            if (rootSelector.ShowDialog(this) == DialogResult.OK)
            {
                txtRootFolder.Text = rootSelector.SelectedPath;
                Console.WriteLine($"Root folder set to: {rootSelector.SelectedPath}");
            }
        }

        private void btnReset_Click(object sender, EventArgs e)
        {
            // Reset dialog to defaults
            folderBrowser.Reset();

            // Reset UI controls
            txtDialogTitle.Text = "Please select a folder...";
            txtRootFolder.Text = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
        }
    }
}

```

--------------------------------

### C# Custom Folder Selection Editor for Properties Window

Source: https://context7.com/willy-kimura/betterfolderbrowser/llms.txt

This C# code demonstrates how to apply custom UITypeEditors for single and multiple folder selections in the .NET Properties window. It uses `SelectedPathEditor` and `SelectedPathsEditor` from the `WK.Libraries.BetterFolderBrowserNS.Editors` namespace. The example includes a sample class `ApplicationSettings` with properties decorated with these editors and a `SettingsForm` to display them in a `PropertyGrid`.

```csharp
using System;
using System.ComponentModel;
using System.Drawing.Design;
using System.Windows.Forms;
using WK.Libraries.BetterFolderBrowserNS.Editors;

namespace CustomEditorExample
{
    // Example class using custom UITypeEditors
    public class ApplicationSettings
    {
        // Single folder selection in Properties window
        [Category("Paths")]
        [Description("The output directory for generated files")]
        [Editor(typeof(SelectedPathEditor), typeof(UITypeEditor))]
        public string OutputDirectory { get; set; }

        // Multiple folder selection in Properties window
        [Category("Paths")]
        [Description("Additional library search paths")]
        [Editor(typeof(SelectedPathsEditor), typeof(UITypeEditor))]
        public string[] LibraryPaths { get; set; }

        [Category("Settings")]
        public string ApplicationName { get; set; }
    }

    // Usage example
    public partial class SettingsForm : Form
    {
        private PropertyGrid propertyGrid;
        private ApplicationSettings settings;

        public SettingsForm()
        {
            InitializeComponent();

            // Initialize settings
            settings = new ApplicationSettings
            {
                OutputDirectory = @"C:\Output",
                LibraryPaths = new string[] { @"C:\Libs", @"C:\External" },
                ApplicationName = "My Application"
            };

            // Display in property grid
            propertyGrid = new PropertyGrid();
            propertyGrid.Dock = DockStyle.Fill;
            propertyGrid.SelectedObject = settings;
            this.Controls.Add(propertyGrid);
        }

        private void SaveSettings()
        {
            Console.WriteLine($"Output Directory: {settings.OutputDirectory}");
            Console.WriteLine("Library Paths:");
            if (settings.LibraryPaths != null)
            {
                foreach (string path in settings.LibraryPaths)
                {
                    Console.WriteLine($"  {path}");
                }
            }
            Console.WriteLine($"Application Name: {settings.ApplicationName}");
        }
    }
}

// When user clicks the "..." button next to OutputDirectory in PropertyGrid:
// - BetterFolderBrowser dialog opens with single-selection mode
// - User selects a folder
// - OutputDirectory property updates with selected path

// When user clicks the "..." button next to LibraryPaths in PropertyGrid:
// - BetterFolderBrowser dialog opens with multi-selection mode
// - User selects multiple folders
// - LibraryPaths property updates with array of selected paths
```

--------------------------------

### Show BetterFolderBrowser from UserControl with Owner (C#)

Source: https://github.com/willy-kimura/betterfolderbrowser/blob/master/README.md

Provides an example of how to show the BetterFolderBrowser dialog from within a UserControl, blocking the UI thread by specifying the form containing the UserControl as the window owner. This ensures proper modality when the component is used in custom controls.

```csharp
    if (betterFolderBrowser.ShowDialog(this.FindForm()) == DialogResult.OK)
    {
        // ...
    }
```

--------------------------------

### Reset BetterFolderBrowser Dialog Properties to Defaults (C#)

Source: https://context7.com/willy-kimura/betterfolderbrowser/llms.txt

Illustrates how to reset all properties of the BetterFolderBrowser dialog to their default values using the `Reset()` method. This is useful when reusing a browser instance for different purposes, ensuring a clean state before applying new configurations. Examples include setting defaults for document selection, program selection, and showing the dialog with factory settings.

```csharp
using System;
using System.Windows.Forms;
using WK.Libraries.BetterFolderBrowserNS;

namespace ResetExample
{
    public class DialogManager
    {
        private BetterFolderBrowser reusableBrowser;

        public DialogManager()
        {
            reusableBrowser = new BetterFolderBrowser();
        }

        public void ConfigureForDocuments()
        {
            reusableBrowser.Title = "Select document folder";
            reusableBrowser.RootFolder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
            reusableBrowser.Multiselect = true;

            if (reusableBrowser.ShowDialog() == DialogResult.OK)
            {
                Console.WriteLine("Selected documents:");
                foreach (string path in reusableBrowser.SelectedFolders)
                {
                    Console.WriteLine($"  {path}");
                }
            }
        }

        public void ConfigureForPrograms()
        {
            // Reset to default values before reconfiguring
            reusableBrowser.Reset();

            // Now configure for different purpose
            reusableBrowser.Title = "Select program folder";
            reusableBrowser.RootFolder = @"C:\Program Files";
            reusableBrowser.Multiselect = false;

            if (reusableBrowser.ShowDialog() == DialogResult.OK)
            {
                Console.WriteLine($"Selected program: {reusableBrowser.SelectedPath}");
            }
        }

        public void ShowDefaultDialog()
        {
            // Reset to defaults:
            // - Title: "Please select a folder..."
            // - RootFolder: Desktop
            // - Multiselect: false
            reusableBrowser.Reset();

            if (reusableBrowser.ShowDialog() == DialogResult.OK)
            {
                Console.WriteLine($"Default selection: {reusableBrowser.SelectedPath}");
            }
        }
    }
}
```

--------------------------------

### Initialize and Show BetterFolderBrowser (C#)

Source: https://github.com/willy-kimura/betterfolderbrowser/blob/master/README.md

Demonstrates how to create an instance of BetterFolderBrowser, set its properties like title and root folder, enable multi-selection, and display the dialog. It also shows how to retrieve the selected folders upon successful dialog completion.

```csharp
    var betterFolderBrowser = new BetterFolderBrowser();

    betterFolderBrowser.Title = "Select folders...";
    betterFolderBrowser.RootFolder = "C:\\";
    
    // Allow multi-selection of folders.
    betterFolderBrowser.Multiselect = true;

    if (betterFolderBrowser.ShowDialog() == DialogResult.OK)
    {
        string[] selectedFolders = betterFolderBrowser1.SelectedFolders;
        
        // If you've disabled multi-selection, use 'SelectedFolder'.
        // string selectedFolder = betterFolderBrowser1.SelectedFolder;
    }
```

--------------------------------

### Application Entry Point (C#)

Source: https://context7.com/willy-kimura/betterfolderbrowser/llms.txt

The Main method of the Program class, marked with STAThread. It enables visual styles, sets compatible text rendering, and runs the main FolderManagerForm. This is the standard entry point for a Windows Forms application.

```csharp
static class Program
{
    [STAThread]
    static void Main()
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new FolderManagerForm());
    }
}
```

--------------------------------

### Designer Integration and Component Usage in C#

Source: https://context7.com/willy-kimura/betterfolderbrowser/llms.txt

Demonstrates adding the BetterFolderBrowser component via the Visual Studio Designer and configuring its properties through the Properties window or code. It shows how to use a pre-configured component to select a path.

```csharp
using System;
using System.ComponentModel;
using System.Windows.Forms;
using WK.Libraries.BetterFolderBrowserNS;

namespace DesignerIntegrationExample
{
    // This form demonstrates designer integration
    public partial class ConfigurationForm : Form
    {
        // Component added via designer
        private BetterFolderBrowser betterFolderBrowser1;
        private IContainer components = null;

        public ConfigurationForm()
        {
            InitializeComponent();

            // Configure component properties
            // (Can also be set in Designer's Properties window)
            betterFolderBrowser1.Title = "Select installation directory";
            betterFolderBrowser1.RootFolder = @"C:\Program Files";
            betterFolderBrowser1.Multiselect = false;
        }

        private void InitializeComponent()
        {
            this.components = new Container();

            // Component initialization (auto-generated by designer)
            this.betterFolderBrowser1 = new BetterFolderBrowser(this.components);

            // Form initialization
            this.Text = "Installation Setup";
        }

        private void btnSelectInstallPath_Click(object sender, EventArgs e)
        {
            // Use pre-configured component
            if (betterFolderBrowser1.ShowDialog(this) == DialogResult.OK)
            {
                string installPath = betterFolderBrowser1.SelectedPath;
                Console.WriteLine($"Installation path: {installPath}");
            }
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing && (components != null))
            {
                components.Dispose();
            }
            base.Dispose(disposing);
        }
    }
}
```

--------------------------------

### Dynamic Root Folder Selection with BetterFolderBrowser (C#)

Source: https://context7.com/willy-kimura/betterfolderbrowser/llms.txt

Demonstrates how to allow users to dynamically change the root folder of the BetterFolderBrowser dialog. This involves using a nested dialog for root selection and updating the main browser's root folder accordingly. It handles user interaction via buttons and updates text boxes with selected paths.

```csharp
using System;
using System.Windows.Forms;
using WK.Libraries.BetterFolderBrowserNS;

namespace DynamicRootExample
{
    public partial class AdvancedBrowserForm : Form
    {
        private TextBox txtRootFolder;
        private TextBox txtSelectedFolder;
        private Button btnChooseRoot;
        private Button btnSelectFolder;
        private BetterFolderBrowser mainBrowser;

        public AdvancedBrowserForm()
        {
            InitializeComponent();

            // Initialize main browser
            mainBrowser = new BetterFolderBrowser();
            mainBrowser.Multiselect = false;

            // Set default root
            txtRootFolder.Text = Environment.GetFolderPath(Environment.SpecialFolder.MyComputer);
        }

        // Button to choose root folder
        private void btnChooseRoot_Click(object sender, EventArgs e)
        {
            // Create temporary browser for root selection
            BetterFolderBrowser rootBrowser = new BetterFolderBrowser();
            rootBrowser.Title = "Choose any folder as the root folder...";
            rootBrowser.RootFolder = @"C:\";
            rootBrowser.Multiselect = false;

            if (rootBrowser.ShowDialog(this) == DialogResult.OK)
            {
                // Update root folder display and main browser
                txtRootFolder.Text = rootBrowser.SelectedPath;
                mainBrowser.RootFolder = rootBrowser.SelectedPath;

                Console.WriteLine($"Root folder changed to: {rootBrowser.SelectedPath}");
            }
        }

        // Button to select folder from current root
        private void btnSelectFolder_Click(object sender, EventArgs e)
        {
            mainBrowser.Title = "Select a folder from the root";
            mainBrowser.RootFolder = txtRootFolder.Text;

            if (mainBrowser.ShowDialog(this) == DialogResult.OK)
            {
                txtSelectedFolder.Text = mainBrowser.SelectedPath;
                Console.WriteLine($"Selected: {mainBrowser.SelectedPath}");
            }
        }
    }
}

// Example interaction:
// 1. Click "Choose Root" -> Select "D:\Projects"
// Output: Root folder changed to: D:\Projects
// 2. Click "Select Folder" -> Select "D:\Projects\MyApp"
// Output: Selected: D:\Projects\MyApp
```

--------------------------------

### Multi-Folder Selection and Processing with BetterFolderBrowser

Source: https://context7.com/willy-kimura/betterfolderbrowser/llms.txt

Illustrates how to enable multi-folder selection using BetterFolderBrowser and process the selected paths. It allows retrieving an array of selected folder paths and iterating through them to perform custom operations, such as calculating directory sizes. The `Multiselect` property must be set to `true`.

```csharp
using System;
using System.IO;
using System.Windows.Forms;
using WK.Libraries.BetterFolderBrowserNS;

namespace MultiFolderExample
{
    public class BatchProcessor
    {
        public void ProcessMultipleFolders()
        {
            var folderBrowser = new BetterFolderBrowser();
            folderBrowser.Title = "Select folders to backup";
            folderBrowser.RootFolder = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
            folderBrowser.Multiselect = true;  // Enable multi-selection

            if (folderBrowser.ShowDialog() == DialogResult.OK)
            {
                // Get all selected folders
                string[] selectedFolders = folderBrowser.SelectedFolders;

                Console.WriteLine($"Selected {selectedFolders.Length} folders:");
                foreach (string folder in selectedFolders)
                {
                    Console.WriteLine($"  - {folder}");

                    // Process each folder
                    DirectoryInfo dirInfo = new DirectoryInfo(folder);
                    Console.WriteLine($"    Size: {GetDirectorySize(dirInfo)} bytes");
                }

                // Alternative property name
                string[] selectedPaths = folderBrowser.SelectedPaths;
            }
            else
            {
                Console.WriteLine("No folders selected");
            }
        }

        private long GetDirectorySize(DirectoryInfo directory)
        {
            long size = 0;
            try
            {
                FileInfo[] files = directory.GetFiles();
                foreach (FileInfo file in files)
                {
                    size += file.Length;
                }
                DirectoryInfo[] subdirs = directory.GetDirectories();
                foreach (DirectoryInfo subdir in subdirs)
                {
                    size += GetDirectorySize(subdir);
                }
            }
            catch (UnauthorizedAccessException)
            {
                // Skip directories we can't access
            }
            return size;
        }
    }
}

// Output example:
// Selected 3 folders:
//   - C:\Users\John\Documents\Photos
//     Size: 52428800 bytes
//   - C:\Users\John\Documents\Videos
//     Size: 157286400 bytes
//   - C:\Users\John\Documents\Projects
//     Size: 10485760 bytes
```

--------------------------------

### Using Custom Editors for Folder Selection in .NET

Source: https://github.com/willy-kimura/betterfolderbrowser/blob/master/README.md

Demonstrates how to use custom UITypeEditors for single and multiple folder selections within the .NET Properties window. These editors, SelectedPathEditor and SelectedPathsEditor, provide a user-friendly interface for selecting folders directly from property grids. Ensure the correct namespace is imported.

```csharp
using WK.Libraries.BetterFolderBrowserNS.Editors;
using System.Drawing.Design;

// Allows selection of one folder.
[Editor(typeof(SelectedPathEditor), typeof(UITypeEditor))]
public string MyFolderPath { get; set; }

// Allows selection of many folders.
[Editor(typeof(SelectedPathsEditor), typeof(UITypeEditor))]
public string[] MyFolderPaths { get; set; }
```

--------------------------------

### Show BetterFolderBrowser with Window Owner (C#)

Source: https://github.com/willy-kimura/betterfolderbrowser/blob/master/README.md

Illustrates how to display the BetterFolderBrowser dialog while blocking the main UI thread by specifying a window owner. This is useful for ensuring the dialog is modal and behaves correctly within the application's window hierarchy.

```csharp
    if (betterFolderBrowser.ShowDialog(this) == DialogResult.OK)
    {
        // ...
    }
```

--------------------------------

### Basic Single Folder Selection with BetterFolderBrowser

Source: https://context7.com/willy-kimura/betterfolderbrowser/llms.txt

Demonstrates how to create and configure BetterFolderBrowser for single folder selection. It allows setting a custom title and root directory, and retrieving the selected folder path. Returns DialogResult.OK if a folder is selected, otherwise DialogResult.Cancel.

```csharp
using System;
using System.Windows.Forms;
using WK.Libraries.BetterFolderBrowserNS;

namespace FolderSelectionExample
{
    public class SingleFolderSelector
    {
        public void SelectFolder()
        {
            // Create and configure the dialog
            var folderBrowser = new BetterFolderBrowser();
            folderBrowser.Title = "Select a project folder";
            folderBrowser.RootFolder = @"C:\Projects";
            folderBrowser.Multiselect = false;

            // Show dialog (non-blocking)
            if (folderBrowser.ShowDialog() == DialogResult.OK)
            {
                string selectedFolder = folderBrowser.SelectedFolder;
                Console.WriteLine($"Selected folder: {selectedFolder}");

                // Alternative property name
                string selectedPath = folderBrowser.SelectedPath;
                Console.WriteLine($"Selected path: {selectedPath}");
            }
            else
            {
                Console.WriteLine("User cancelled the dialog");
            }
        }
    }
}

// Output example:
// Selected folder: C:\Projects\MyApplication
// Selected path: C:\Projects\MyApplication
```

--------------------------------

### Display Modal Dialog with Window Owner in C#

Source: https://context7.com/willy-kimura/betterfolderbrowser/llms.txt

Shows how to display the BetterFolderBrowser as a modal dialog, blocking the parent form's UI thread. It accepts the parent form as an owner and handles the selected path. Usage from both a Form and a UserControl is demonstrated.

```csharp
using System;
using System.Windows.Forms;
using WK.Libraries.BetterFolderBrowserNS;

namespace ModalDialogExample
{
    public partial class MainForm : Form
    {
        private TextBox txtSelectedPath;
        private Button btnBrowse;

        public MainForm()
        {
            InitializeComponent();
        }

        private void btnBrowse_Click(object sender, EventArgs e)
        {
            var folderBrowser = new BetterFolderBrowser();
            folderBrowser.Title = "Select output directory";
            folderBrowser.RootFolder = @"C:\";

            // Show modal dialog - blocks UI thread
            // 'this' refers to the parent Form
            if (folderBrowser.ShowDialog(this) == DialogResult.OK)
            {
                txtSelectedPath.Text = folderBrowser.SelectedPath;
                MessageBox.Show(this,
                    $"You selected: {folderBrowser.SelectedPath}",
                    "Folder Selected",
                    MessageBoxButtons.OK,
                    MessageBoxIcon.Information);
            }
        }
    }

    // Usage from UserControl
    public partial class FolderSelectorControl : UserControl
    {
        private void SelectFolderFromUserControl()
        {
            var folderBrowser = new BetterFolderBrowser();
            folderBrowser.Title = "Choose a folder";

            // Get parent form and use as owner
            Form parentForm = this.FindForm();
            if (folderBrowser.ShowDialog(parentForm) == DialogResult.OK)
            {
                Console.WriteLine($"Selected: {folderBrowser.SelectedPath}");
            }
        }
    }
}
```

--------------------------------

### Configure Folder Browser Multiselect (C#)

Source: https://context7.com/willy-kimura/betterfolderbrowser/llms.txt

Handles theCheckedChanged event for the multiselect checkbox. It updates the folder browser's multiselect property and logs the change to the console. This allows users to enable or disable selecting multiple folders.

```csharp
private void chkAllowMultiselect_CheckedChanged(object sender, EventArgs e)
{
    folderBrowser.Multiselect = chkAllowMultiselect.Checked;

    string mode = chkAllowMultiselect.Checked ? "enabled" : "disabled";
    Console.WriteLine($"Multi-selection {mode}");
}
```

--------------------------------

### Reset Folder Browser Dialog State (C#)

Source: https://context7.com/willy-kimura/betterfolderbrowser/llms.txt

Resets the state of the folder browser dialog by clearing selected items, setting a status label, and logging the action to the console. This is typically called when initializing or resetting the dialog.

```csharp
chkAllowMultiselect.Checked = false;
lstSelectedFolders.Items.Clear();
lblStatus.Text = "Dialog reset to defaults";
lblStatus.Visible = true;

Console.WriteLine("Dialog reset to default values");
```
Tokens:
Raw