/// <summary>
        /// 指定したパスを実行します。
        /// </summary>
        /// <param name="executePathes">実行するパス</param>
        private void ExecuteDataGridSelectedPathes(params PathInfo[] executePathes)
        {
            PathInfo[] files = executePathes.Where(path => path.Type == PathInfo.PathType.File).ToArray();

            foreach (PathInfo file in files)
            {
                using (Process.Start(file.FullPath)) { }
            }

            PathInfo[] directories = executePathes.Where(path => path.Type == PathInfo.PathType.Directory).ToArray();

            if (directories.Count() == 1)
            {
                PathInfo singleDirectory = directories.Single();

                if ((singleDirectory.Attributes & FileAttributes.ReparsePoint) == FileAttributes.ReparsePoint)
                {
                    MessageBox.Show(
                        string.Format("{0}にアクセスできません。{1}{1}アクセスが拒否されました。", singleDirectory.FullPath, Environment.NewLine), this.Content.ToString(), MessageBoxButton.OK, MessageBoxImage.Error);
                    return;
                }

                DirectorySelectState directoryState =
                    new DirectorySelectState(singleDirectory);

                this.DirectoryHistory.Add(directoryState);
                this.OpenDirectoryAtDataGrid();
                return;
            }

            foreach (PathInfo directory in directories)
            {
                Process.Start(System.Windows.Forms.Application.ExecutablePath,
                    directory.FullPath);
            }
        }
        private void Window_Initialized(object sender, EventArgs e)
        {
            this.DataGridWrapperModelExtender = new DataGridWrapperModelExtender<PathInfo>(this.dataGrid);
            this.DataGridEditExtender = new DataGridEditExtender(this.dataGrid);

            DirectorySelectState directoryState =
                new DirectorySelectState(new PathInfo(this.InitializeDirectory));

            this.DirectoryHistory.Add(directoryState);
            this.OpenDirectoryAtDataGrid();

            this.dataGrid.FocusFirstCell();
        }
        private void dataGrid_PreviewKeyDown(object sender, System.Windows.Input.KeyEventArgs e)
        {
            if (this.DataGridEditExtender.IsEditing == true)
            {
                return;
            }

            bool isHandled = true;

            try
            {
                PathInfo[] selectedPathes = this.DataGridWrapperModelExtender.SelectedDataContexts;

                if ((Keyboard.Modifiers & ModifierKeys.Alt) == ModifierKeys.Alt && Keyboard.IsKeyDown(Key.Left) == true)
                {
                    if (this.DirectoryHistory.MovePrevious() == false)
                    {
                        return;
                    }
                    this.OpenDirectoryAtDataGrid();
                    return;
                }
                else if ((Keyboard.Modifiers & ModifierKeys.Alt) == ModifierKeys.Alt && Keyboard.IsKeyDown(Key.Right) == true)
                {
                    if (this.DirectoryHistory.MoveNext() == false)
                    {
                        return;
                    }
                    this.OpenDirectoryAtDataGrid();
                    return;
                }
                else if ((Keyboard.Modifiers & ModifierKeys.Control) == ModifierKeys.Control && Keyboard.IsKeyDown(Key.L) == true)
                {
                    this.addressBar.Focus();
                    return;
                }
                else if (Keyboard.IsKeyDown(Key.Delete) == true)
                {
                    if (selectedPathes.Any() == false)
                    {
                        return;
                    }

                    if (MessageBox.Show("削除していいですか?", "ClassicalFilter", MessageBoxButton.YesNo, MessageBoxImage.Information) == MessageBoxResult.No)
                    {
                        return;
                    }

                    List<object> removeList = new List<object>();

                    foreach (dynamic item in this.dataGrid.SelectedItems)
                    {
                        PathInfo pathItem = item.Instance as PathInfo;
                        pathItem.Delete();

                        removeList.Add(item);
                    }

                    this.dataGrid.ItemsSource = DataGridWrapperModelExtender<PathInfo>.CreateWrapModel(this.DirectoryHistory.Current.Directory.GetChildren());
                    this.dataGrid.SelectedItem = this.dataGrid.Items.Cast<object>().First();

                    this.dataGrid.FocusFirstCell();
                    return;
                }
                else if ((Keyboard.Modifiers & ModifierKeys.Control) == ModifierKeys.Control && Keyboard.IsKeyDown(Key.C) == true)
                {
                    if (selectedPathes.Any() == false)
                    {
                        return;
                    }
                    List<PathInfo> list = new List<PathInfo>();
                    foreach (dynamic item in this.dataGrid.SelectedItems)
                    {
                        PathInfo pathInfo = item.Instance as PathInfo;
                        list.Add(pathInfo);
                    }

                    PathClipboard.Copy(list.ToArray());
                    e.Handled = true;
                    return;
                }
                else if ((Keyboard.Modifiers & ModifierKeys.Control) == ModifierKeys.Control && Keyboard.IsKeyDown(Key.X) == true)
                {
                    if (selectedPathes.Any() == false)
                    {
                        return;
                    }

                    List<PathInfo> list = new List<PathInfo>();
                    foreach (dynamic item in this.dataGrid.SelectedItems)
                    {
                        PathInfo pathInfo = item.Instance as PathInfo;
                        list.Add(pathInfo);
                    }

                    PathClipboard.Cut(list.ToArray());
                    return;
                }
                else if ((Keyboard.Modifiers & ModifierKeys.Control) == ModifierKeys.Control && Keyboard.IsKeyDown(Key.V) == true)
                {
                    PathPasteContext context = PathClipboard.Context;

                    PasteType pasteType = context.Type;

                    foreach (PathInfo path in context.Values)
                    {
                        PathInfo newPath = this.DirectoryHistory.Current.Directory.Combine(path.Name);
                        if (pasteType == PasteType.Copy)
                        {
                            path.Copy(newPath);
                        }
                        else
                        {
                            path.Move(newPath);
                        }

                        dynamic[] dynamicPath = DataGridWrapperModelExtender<PathInfo>.CreateWrapModel(newPath);
                        foreach (dynamic d in dynamicPath)
                        {
                            List<object> itemlist = this.dataGrid.ItemsSource.Cast<object>().ToList();
                            itemlist.Add(d);
                            this.dataGrid.ItemsSource = itemlist.ToArray();
                        }
                    }
                    this.dataGrid.FocusFirstCell();
                    return;
                }
                else if (Keyboard.IsKeyDown(Key.F2) == true)
                {
                    if (selectedPathes.Any() == false)
                    {
                        return;
                    }

                    this.DataGridEditExtender.BeginEdit();
                    return;
                }
                else if (Keyboard.IsKeyDown(Key.Left) == true)
                {
                    PathInfo selectDirectory = this.DirectoryHistory.Current.Directory;
                    PathInfo nextDirectory = selectDirectory.ParentDirectory;

                    if (nextDirectory == null)
                    {
                        return;
                    }

                    DirectorySelectState directoryState =
                        new DirectorySelectState(nextDirectory);

                    this.DirectoryHistory.Add(directoryState);

                    this.DirectoryHistory.Current.SelectPathes = new PathInfo[] { selectDirectory };
                    this.OpenDirectoryAtDataGrid();
                    return;
                }
                else if (Keyboard.IsKeyDown(Key.Enter) || Keyboard.IsKeyDown(Key.Right))
                {
                    if (selectedPathes.Any() == false)
                    {
                        return;
                    }

                    this.ExecuteDataGridSelectedPathes(selectedPathes);
                    return;
                }
                else if (e.Key == Key.Back)
                {
                    if (this.IsSearchModeAtAddressBar == true)
                    {
                        this.SearchStringAtAddressBar =
                            this.SearchStringAtAddressBar.RemoveLast();
                    }
                    this.FilterDataGrid();
                    return;
                }
                else if (e.Key == Key.Escape)
                {
                    this.SearchStringAtAddressBar = null;
                    this.FilterDataGrid();
                    return;
                }
                else if (this.AlphabetDefineString.Contains(e.Key.ToString()) == true)
                {
                    this.SearchStringAtAddressBar =
                        this.SearchStringAtAddressBar.Append(e.Key.ToString());

                    this.FilterDataGrid();
                    return;
                }
                isHandled = false;
            }
            finally
            {
                e.Handled = isHandled;
            }
        }