ronantakizawa/codereview-bench huggingface dataset:
Repository: files-community/Files
File: src/Files.App/Actions/Open/OpenSettingsAction.cs (C#)

Code before:
﻿// Copyright (c) 2024 Files Community
// Licensed under the MIT License. See the LICENSE.

namespace Files.App.Actions
{
	internal sealed class OpenSettingsAction : BaseUIAction, IAction
	{
		private readonly IDialogService dialogService = Ioc.Default.GetRequiredService<IDialogService>();

		private readonly SettingsDialogViewModel viewModel = new();

		public string Label
			=> "Settings".GetLocalizedResource();

		public string Description
			=> "OpenSettingsDescription".GetLocalizedResource();

		public HotKey HotKey
			=> new(Keys.OemComma, KeyModifiers.Ctrl);

		public Task ExecuteAsync(object? parameter = null)
		{
			var dialog = dialogService.GetDialog(viewModel);
			return dialog.TryShowAsync();
		}
	}
}


Review comment (suggestion):
```suggestion
			if (parameter is SettingsNavigationParams navParams)
```

Code after:
﻿// Copyright (c) 2024 Files Community
// Licensed under the MIT License. See the LICENSE.

using Files.App.Dialogs;

namespace Files.App.Actions
{
	internal sealed class OpenSettingsAction : BaseUIAction, IAction
	{
		private readonly IDialogService dialogService = Ioc.Default.GetRequiredService<IDialogService>();

		private readonly SettingsDialogViewModel viewModel = new();

		public string Label
			=> "Settings".GetLocalizedResource();

		public string Description
			=> "OpenSettingsDescription".GetLocalizedResource();

		public HotKey HotKey
			=> new(Keys.OemComma, KeyModifiers.Ctrl);

		public Task ExecuteAsync(object? parameter = null)
		{
			var dialog = dialogService.GetDialog(viewModel);
			if (parameter is not null && parameter is SettingsNavigationParams navParams)
				((SettingsDialog)dialog).NavigateTo(navParams);

			return dialog.TryShowAsync();
		}
	}
}
Repository: files-community/Files
File: src/Files.App/Actions/Content/Background/SetAsLockscreenBackgroundAction.cs (C#)

Code before:
		public override string Label
			=> "SetAsLockscreen".GetLocalizedResource();

		public override string Description
			=> "SetAsLockscreenBackgroundDescription".GetLocalizedResource();

		public override RichGlyph Glyph
			=> new("\uEE3F");

		public override bool IsExecutable =>
			base.IsExecutable &&
			ContentPageContext.SelectedItem is not null;

		public override Task ExecuteAsync(object? parameter = null)
		{
			if (ContentPageContext.SelectedItem is null)
				return Task.CompletedTask;

			try
			{
				return WindowsWallpaperService.SetLockScreenWallpaper(ContentPageContext.SelectedItem.ItemPath);
			}
			catch (Exception ex)
			{
				ShowErrorDialog(ex.Message);
				App.Logger.LogWarning(ex, ex.Message);

				return Task.CompletedTask;
			}
		}
	}
}


Review comment (bug):
I don't think logging helps us because there isn't anything to do for this type of exception. The best thing is to notify the user and prevent a crash.

Code after:
		public override string Label
			=> "SetAsLockscreen".GetLocalizedResource();

		public override string Description
			=> "SetAsLockscreenBackgroundDescription".GetLocalizedResource();

		public override RichGlyph Glyph
			=> new("\uEE3F");

		public override bool IsExecutable =>
			base.IsExecutable &&
			ContentPageContext.SelectedItem is not null;

		public override Task ExecuteAsync(object? parameter = null)
		{
			if (!IsExecutable || ContentPageContext.SelectedItem is not ListedItem selectedItem)
				return Task.CompletedTask;

			try
			{
				return WindowsWallpaperService.SetLockScreenWallpaper(selectedItem.ItemPath);
			}
			catch (Exception ex)
			{
				ShowErrorDialog(ex.Message);

				return Task.CompletedTask;
			}
		}
	}
}
Repository: files-community/Files
File: src/Files.App/Actions/Content/Background/SetAsSlideshowBackgroundAction.cs (C#)

Code before:

		public override string Description
			=> "SetAsSlideshowBackgroundDescription".GetLocalizedResource();

		public override RichGlyph Glyph
			=> new("\uE91B");

		public override bool IsExecutable =>
			base.IsExecutable &&
			ContentPageContext.SelectedItems.Count > 1;

		public override Task ExecuteAsync(object? parameter = null)
		{
			if (ContentPageContext.SelectedItems.Count <= 1)
				return Task.CompletedTask;

			var paths = ContentPageContext.SelectedItems.Select(item => item.ItemPath).ToArray();

			try
			{
				WindowsWallpaperService.SetDesktopSlideshow(paths);
			}
			catch (Exception ex)
			{
				ShowErrorDialog(ex.Message);
				App.Logger.LogWarning(ex, ex.Message);
			}

			return Task.CompletedTask;
		}
	}
}


Review comment (bug):
I don't think logging helps us because there isn't anything to do for this type of exception. The best thing is to notify the user and prevent a crash.

Code after:

		public override string Description
			=> "SetAsSlideshowBackgroundDescription".GetLocalizedResource();

		public override RichGlyph Glyph
			=> new("\uE91B");

		public override bool IsExecutable =>
			base.IsExecutable &&
			ContentPageContext.SelectedItems.Count > 1;

		public override Task ExecuteAsync(object? parameter = null)
		{
			if (!IsExecutable || ContentPageContext.SelectedItems.Select(item => item.ItemPath).ToArray() is not string[] paths || paths.Length is 0)
				return Task.CompletedTask;

			try
			{
				WindowsWallpaperService.SetDesktopSlideshow(paths);
			}
			catch (Exception ex)
			{
				ShowErrorDialog(ex.Message);
			}

			return Task.CompletedTask;
		}
	}
}
Repository: files-community/Files
File: src/Files.App/Actions/Content/Background/SetAsWallpaperBackgroundAction.cs (C#)

Code before:
		public override string Label
			=> "SetAsBackground".GetLocalizedResource();

		public override string Description
			=> "SetAsWallpaperBackgroundDescription".GetLocalizedResource();

		public override RichGlyph Glyph
			=> new("\uE91B");

		public override bool IsExecutable =>
			base.IsExecutable &&
			ContentPageContext.SelectedItem is not null;

		public override Task ExecuteAsync(object? parameter = null)
		{
			if (ContentPageContext.SelectedItem is null)
				return Task.CompletedTask;

			try
			{
				WindowsWallpaperService.SetDesktopWallpaper(ContentPageContext.SelectedItem.ItemPath);
			}
			catch (Exception ex)
			{
				ShowErrorDialog(ex.Message);
				App.Logger.LogWarning(ex, ex.Message);
			}

			return Task.CompletedTask;
		}
	}
}


Review comment (bug):
I don't think logging helps us because there isn't anything to do for this type of exception. The best thing is to notify the user and prevent a crash.

Code after:
		public override string Label
			=> "SetAsBackground".GetLocalizedResource();

		public override string Description
			=> "SetAsWallpaperBackgroundDescription".GetLocalizedResource();

		public override RichGlyph Glyph
			=> new("\uE91B");

		public override bool IsExecutable =>
			base.IsExecutable &&
			ContentPageContext.SelectedItem is not null;

		public override Task ExecuteAsync(object? parameter = null)
		{
			if (!IsExecutable || ContentPageContext.SelectedItem is not ListedItem selectedItem)
				return Task.CompletedTask;

			try
			{
				WindowsWallpaperService.SetDesktopWallpaper(selectedItem.ItemPath);
			}
			catch (Exception ex)
			{
				ShowErrorDialog(ex.Message);
			}

			return Task.CompletedTask;
		}
	}
}
Repository: files-community/Files
File: src/Files.App/Actions/Content/Background/SetAsSlideshowBackgroundAction.cs (C#)

Code before:

using Microsoft.Extensions.Logging;

namespace Files.App.Actions
{
	internal sealed class SetAsSlideshowBackgroundAction : BaseSetAsAction
	{
		private readonly IWindowsWallpaperService WindowsWallpaperService = Ioc.Default.GetRequiredService<IWindowsWallpaperService>();

		public override string Label
			=> "SetAsSlideshow".GetLocalizedResource();

		public override string Description
			=> "SetAsSlideshowBackgroundDescription".GetLocalizedResource();

		public override RichGlyph Glyph
			=> new("\uE91B");

		public override bool IsExecutable =>
			base.IsExecutable &&
			ContentPageContext.SelectedItems.Count > 1;

		public override Task ExecuteAsync(object? parameter = null)
		{
			if (!IsExecutable || ContentPageContext.SelectedItems.Select(item => item.ItemPath).ToArray() is not string[] paths || paths.Length is not 0)
				return Task.CompletedTask;

			try
			{
				WindowsWallpaperService.SetDesktopSlideshow(paths);
			}
			catch (Exception ex)
			{
				ShowErrorDialog(ex.Message);
			}

			return Task.CompletedTask;
		}
	}
}


Review comment (suggestion):
```suggestion
			if (!IsExecutable || ContentPageContext.SelectedItems.Select(item => item.ItemPath).ToArray() is not string[] paths || paths.Length is 0)
				return Task.CompletedTask;
```

Code after:

using Microsoft.Extensions.Logging;

namespace Files.App.Actions
{
	internal sealed class SetAsSlideshowBackgroundAction : BaseSetAsAction
	{
		private readonly IWindowsWallpaperService WindowsWallpaperService = Ioc.Default.GetRequiredService<IWindowsWallpaperService>();

		public override string Label
			=> "SetAsSlideshow".GetLocalizedResource();

		public override string Description
			=> "SetAsSlideshowBackgroundDescription".GetLocalizedResource();

		public override RichGlyph Glyph
			=> new("\uE91B");

		public override bool IsExecutable =>
			base.IsExecutable &&
			ContentPageContext.SelectedItems.Count > 1;

		public override Task ExecuteAsync(object? parameter = null)
		{
			if (!IsExecutable || ContentPageContext.SelectedItems.Select(item => item.ItemPath).ToArray() is not string[] paths || paths.Length is 0)
				return Task.CompletedTask;

			try
			{
				WindowsWallpaperService.SetDesktopSlideshow(paths);
			}
			catch (Exception ex)
			{
				ShowErrorDialog(ex.Message);
			}

			return Task.CompletedTask;
		}
	}
}
Repository: files-community/Files
File: src/Files.App/MainWindow.xaml.cs (C#)

Code before:
							{
								var target = IO.Path.GetFullPath(IO.Path.Combine(activationPath, command.Payload));
								await PerformNavigationAsync(target);
							}
							else
							{
								await PerformNavigationAsync(null);
							}
						}
						break;

					case ParsedCommandType.OutputPath:
						App.OutputPath = command.Payload;
						break;
				}
			}
		}

		public bool SetCanWindowToFront(bool canWindowToFront)
		{
			if (CanWindowToFront != canWindowToFront)
			{
				CanWindowToFront = canWindowToFront;
				return true;
			}
			return false;
		}

		private const int WM_WINDOWPOSCHANGING = 0x0046;
		private void WindowManager_WindowMessageReceived(object? sender, WinUIEx.Messaging.WindowMessageEventArgs e)
		{
			if (!CanWindowToFront)
			{
				if (e.Message.MessageId == WM_WINDOWPOSCHANGING)
				{
					Win32Helper.ForceWindowPosition(e.Message.LParam);
					e.Handled = true;
				}
			}
		}
	}
}


Review comment (suggestion):
This does not guarantee atomic operation when multiple threads handle it at the same time. It is better to use `Interlocked` class or `lock` statement.

Code after:
							if (!string.IsNullOrEmpty(command.Payload))
							{
								var target = IO.Path.GetFullPath(IO.Path.Combine(activationPath, command.Payload));
								await PerformNavigationAsync(target);
							}
							else
							{
								await PerformNavigationAsync(null);
							}
						}
						break;

					case ParsedCommandType.OutputPath:
						App.OutputPath = command.Payload;
						break;
				}
			}
		}

		public bool SetCanWindowToFront(bool canWindowToFront)
		{
			lock (_canWindowToFrontLock)
			{
				if (CanWindowToFront != canWindowToFront)
				{
					CanWindowToFront = canWindowToFront;
					return true;
				}
				return false;
			}
		}

		private const int WM_WINDOWPOSCHANGING = 0x0046;
		private void WindowManager_WindowMessageReceived(object? sender, WinUIEx.Messaging.WindowMessageEventArgs e)
		{
			if ((!CanWindowToFront) && e.Message.MessageId == WM_WINDOWPOSCHANGING)
			{
				Win32Helper.ForceWindowPosition(e.Message.LParam);
				e.Handled = true;
			}
		}
	}
}
Repository: files-community/Files
File: src/Files.App/MainWindow.xaml.cs (C#)

Code before:
						break;
				}
			}
		}

		public bool SetCanWindowToFront(bool canWindowToFront)
		{
			if (CanWindowToFront != canWindowToFront)
			{
				CanWindowToFront = canWindowToFront;
				return true;
			}
			return false;
		}

		private const int WM_WINDOWPOSCHANGING = 0x0046;
		private void WindowManager_WindowMessageReceived(object? sender, WinUIEx.Messaging.WindowMessageEventArgs e)
		{
			if (!CanWindowToFront)
			{
				if (e.Message.MessageId == WM_WINDOWPOSCHANGING)
				{
					Win32Helper.ForceWindowPosition(e.Message.LParam);
					e.Handled = true;
				}
			}
		}
	}
}


Review comment (refactor):
```suggestion
			if (!CanWindowToFront && e.Message.MessageId == WM_WINDOWPOSCHANGING)
			{
				Win32Helper.ForceWindowPosition(e.Message.LParam);
				e.Handled = true;
			}
```

Code after:
						App.OutputPath = command.Payload;
						break;
				}
			}
		}

		public bool SetCanWindowToFront(bool canWindowToFront)
		{
			lock (_canWindowToFrontLock)
			{
				if (CanWindowToFront != canWindowToFront)
				{
					CanWindowToFront = canWindowToFront;
					return true;
				}
				return false;
			}
		}

		private const int WM_WINDOWPOSCHANGING = 0x0046;
		private void WindowManager_WindowMessageReceived(object? sender, WinUIEx.Messaging.WindowMessageEventArgs e)
		{
			if ((!CanWindowToFront) && e.Message.MessageId == WM_WINDOWPOSCHANGING)
			{
				Win32Helper.ForceWindowPosition(e.Message.LParam);
				e.Handled = true;
			}
		}
	}
}
Repository: files-community/Files
File: src/Files.App/MainWindow.xaml.cs (C#)

Code before:
							else
							{
								await PerformNavigationAsync(null);
							}
						}
						break;

					case ParsedCommandType.OutputPath:
						App.OutputPath = command.Payload;
						break;
				}
			}
		}

        public bool SetCanWindowToFront(bool canWindowToFront)
        {
            lock (_canWindowToFrontLock)
            {
                if (CanWindowToFront != canWindowToFront)
                {
                    CanWindowToFront = canWindowToFront;
                    return true;
                }
                return false;
            }
        }

		private const int WM_WINDOWPOSCHANGING = 0x0046;
		private void WindowManager_WindowMessageReceived(object? sender, WinUIEx.Messaging.WindowMessageEventArgs e)
		{
			if ((!CanWindowToFront) && e.Message.MessageId == WM_WINDOWPOSCHANGING)
			{
				Win32Helper.ForceWindowPosition(e.Message.LParam);
				e.Handled = true;
			}
		}
	}
}


Review comment (suggestion):
Use tabs for indentation.
```suggestion
		public bool SetCanWindowToFront(bool canWindowToFront)
		{
			lock (_canWindowToFrontLock)
			{
				if (CanWindowToFront != canWindowToFront)
				{
					CanWindowToFront = canWindowToFront;
					return true;
				}
				return false;
			}
		}
```

Code after:
							else
							{
								await PerformNavigationAsync(null);
							}
						}
						break;

					case ParsedCommandType.OutputPath:
						App.OutputPath = command.Payload;
						break;
				}
			}
		}

		public bool SetCanWindowToFront(bool canWindowToFront)
		{
			lock (_canWindowToFrontLock)
			{
				if (CanWindowToFront != canWindowToFront)
				{
					CanWindowToFront = canWindowToFront;
					return true;
				}
				return false;
			}
		}

		private const int WM_WINDOWPOSCHANGING = 0x0046;
		private void WindowManager_WindowMessageReceived(object? sender, WinUIEx.Messaging.WindowMessageEventArgs e)
		{
			if ((!CanWindowToFront) && e.Message.MessageId == WM_WINDOWPOSCHANGING)
			{
				Win32Helper.ForceWindowPosition(e.Message.LParam);
				e.Handled = true;
			}
		}
	}
}
Repository: files-community/Files
File: src/Files.App/Data/Enums/PreviewPaneStates.cs (C#)

Code before:
		NoItemSelected,

		/// <summary>
		/// No preview available status.
		/// </summary>
		NoPreviewAvailable,

		/// <summary>
		/// No preview or details available status.
		/// </summary>
		NoPreviewOrDetailsAvailable,

		/// <summary>
		/// Preview and details available status.
		/// </summary>
		PreviewAndDetailsAvailable,

		/// <summary>
		/// Loading preview status.
		/// </summary>
		LoadingPreview,

		/// <summary>
		/// Drive preview and details available status.
		/// </summary>
		DrivePreviewAndDetailsAvailable,
	}
}


Review comment (suggestion):
```suggestion
		DriveStorageDetailsAvailable,
```

Code after:
		NoItemSelected,

		/// <summary>
		/// No preview available status.
		/// </summary>
		NoPreviewAvailable,

		/// <summary>
		/// No preview or details available status.
		/// </summary>
		NoPreviewOrDetailsAvailable,

		/// <summary>
		/// Preview and details available status.
		/// </summary>
		PreviewAndDetailsAvailable,

		/// <summary>
		/// Loading preview status.
		/// </summary>
		LoadingPreview,

		/// <summary>
		/// Drive preview and details available status.
		/// </summary>
		DriveStorageDetailsAvailable,
	}
}
Repository: files-community/Files
File: src/Files.App/Helpers/NaturalStringComparer.cs (C#)

Code before:
		        var i = 0;
		        while (i < span.Length && char.IsDigit(span[i]))
		        {
		            i++;
		        }

		        number = span.Slice(0, i);
		        return span.Slice(i);
		    }

		    private static int CompareNumValues(ReadOnlySpan<char> numValue1, ReadOnlySpan<char> numValue2)
		    {
		        var num1AsSpan = numValue1.TrimStart('0');
		        var num2AsSpan = numValue2.TrimStart('0');

		        if (num1AsSpan.Length < num2AsSpan.Length) return -1;

		        if (num1AsSpan.Length > num2AsSpan.Length) return 1;

		        var compareResult = num1AsSpan.CompareTo(num2AsSpan, StringComparison.Ordinal);

		        if (compareResult != 0) return Math.Sign(compareResult);

		        if (numValue2.Length == numValue1.Length) return compareResult;

		        return numValue2.Length < numValue1.Length ? -1 : 1; // "033" < "33" === true
		    }
		}
	}
}


Review comment (suggestion):
```suggestion
		        return numValue2.Length < numValue1.Length ? -1 : 1; // "033" < "33" == true
```

Code after:
		            if (charCompareResult != 0) return charCompareResult;
		        }

		        return x.Length.CompareTo(y.Length);
		    }

		    private static ReadOnlySpan<char> GetNumber(ReadOnlySpan<char> span, out ReadOnlySpan<char> number)
		    {
		        var i = 0;
		        while (i < span.Length && char.IsDigit(span[i]))
		        {
		            i++;
		        }

		        number = span.Slice(0, i);
		        return span.Slice(i);
		    }

		    private static int CompareNumValues(ReadOnlySpan<char> numValue1, ReadOnlySpan<char> numValue2)
		    {
		        var num1AsSpan = numValue1.TrimStart('0');
		        var num2AsSpan = numValue2.TrimStart('0');

		        if (num1AsSpan.Length < num2AsSpan.Length) return -1;

		        if (num1AsSpan.Length > num2AsSpan.Length) return 1;

		        var compareResult = num1AsSpan.CompareTo(num2AsSpan, StringComparison.Ordinal);

		        if (compareResult != 0) return Math.Sign(compareResult);

		        if (numValue2.Length == numValue1.Length) return compareResult;

		        return numValue2.Length < numValue1.Length ? -1 : 1; // "033" < "33" == true
		    }
		}
	}
}
Repository: files-community/Files
File: src/Files.App/Views/ShellPanesPage.xaml.cs (C#)

Code before:
					if (GetPane(1) is ModernShellPage page)
						page.NavParams = value!;
				}
			}
		}

		private IShellPage? _ActivePane;
		public IShellPage? ActivePane
		{
			get => _ActivePane;
			set
			{
				if (_ActivePane != value)
				{
					_ActivePane = value;

					// Reset
					if (GetPane(0) is ModernShellPage firstShellPage)
						firstShellPage.IsCurrentInstance = false;
					if (GetPane(1) is ModernShellPage secondShellPage)
						secondShellPage.IsCurrentInstance = false;

					if (ActivePane is not null)
					{
						ActivePane.IsCurrentInstance = IsCurrentInstance;
					}

					NotifyPropertyChanged(nameof(ActivePane));
					NotifyPropertyChanged(nameof(IsLeftPaneActive));
					NotifyPropertyChanged(nameof(IsRightPaneActive));
					NotifyPropertyChanged(nameof(ActivePaneOrColumn));
					NotifyPropertyChanged(nameof(FilesystemHelpers));

					SetShadow();
				}
			}
		}

		private bool _IsCurrentInstance;
		public bool IsCurrentInstance
		{
			get => _IsCurrentInstance;
			set
			{
				if (_IsCurrentInstance == value)
					return;

				_IsCurrentInstance = value;

				// Reset
				if (GetPane(0) is ModernShellPage firstShellPage)

Review comment (suggestion):
```suggestion
						ActivePane.IsCurrentInstance = IsCurrentInstance;
```

Code after:
					if (GetPane(1) is ModernShellPage page)
						page.NavParams = value!;
				}
			}
		}

		private IShellPage? _ActivePane;
		public IShellPage? ActivePane
		{
			get => _ActivePane;
			set
			{
				if (_ActivePane != value)
				{
					_ActivePane = value;

					// Reset
					if (GetPane(0) is ModernShellPage firstShellPage)
						firstShellPage.IsCurrentInstance = false;
					if (GetPane(1) is ModernShellPage secondShellPage)
						secondShellPage.IsCurrentInstance = false;

					if (ActivePane is not null)
						ActivePane.IsCurrentInstance = IsCurrentInstance;

					NotifyPropertyChanged(nameof(ActivePane));
					NotifyPropertyChanged(nameof(IsLeftPaneActive));
					NotifyPropertyChanged(nameof(IsRightPaneActive));
					NotifyPropertyChanged(nameof(ActivePaneOrColumn));
					NotifyPropertyChanged(nameof(FilesystemHelpers));

					SetShadow();
				}
			}
		}

		private bool _IsCurrentInstance;
		public bool IsCurrentInstance
		{
			get => _IsCurrentInstance;
			set
			{
				if (_IsCurrentInstance == value)
					return;

				_IsCurrentInstance = value;

				// Reset
				if (GetPane(0) is ModernShellPage firstShellPage)
					firstShellPage.IsCurrentInstance = false;
				if (GetPane(1) is ModernShellPage secondShellPage)
Repository: files-community/Files
File: src/Files.App/Data/Contracts/IShellPanesPage.cs (C#)

Code before:
		/// </summary>
		/// <param name="path">The path to open in the new pane.</param>
		public void OpenSecondaryPane(string path = "", ShellPaneArrangement arrangement = ShellPaneArrangement.None);

		/// <summary>
		/// Arranges panes with the specified arrangement.
		/// </summary>
		/// <param name="arrangement">The arrangement to set.</param>
		public void ArrangePanes(ShellPaneArrangement arrangement = ShellPaneArrangement.None);

		/// <summary>
		/// Closes the shell active/focused pane.
		/// </summary>
		public void CloseActivePane();

		/// <summary>
		/// Focuses the other pane.
		/// </summary>
		public void FocusOtherPane();

		/// <summary>
		/// Updates the layout of open panes.
		/// </summary>
		/// <param name="targetPath">The path of panes to update</param>
		/// <param name="includeActivePane">Whether the active pane should be updated or not</param>
		public void UpdatePanesLayout(string targetPath, bool includeActivePane = false);
	}
}


Review comment (suggestion):
```suggestion
		public void UpdateOpenPanesPreferences(string targetPath, bool includeActivePane = false);
```

Code after:
		/// </summary>
		/// <param name="path">The path to open in the new pane.</param>
		public void OpenSecondaryPane(string path = "", ShellPaneArrangement arrangement = ShellPaneArrangement.None);

		/// <summary>
		/// Arranges panes with the specified arrangement.
		/// </summary>
		/// <param name="arrangement">The arrangement to set.</param>
		public void ArrangePanes(ShellPaneArrangement arrangement = ShellPaneArrangement.None);

		/// <summary>
		/// Closes the shell active/focused pane.
		/// </summary>
		public void CloseActivePane();

		/// <summary>
		/// Focuses the other pane.
		/// </summary>
		public void FocusOtherPane();

		/// <summary>
		/// Gets open panes.
		/// </summary>
		/// <returns>An enumerable containing open panes.</returns>
		public IEnumerable<ModernShellPage> GetPanes();
	}
}