Ejemplo n.º 1
0
        /// <summary>
        /// FindReplaceDialog
        /// </summary>
        /// <param name="editor"></param>
        public FindReplaceDialog(BindableTextEditor editor, TreeView nodePanel)
        {
            this.DataContext = new FindReplaceDialogViewModel(_Model, editor);
            this.Editor      = editor;
            this.NodePanel   = nodePanel;

            InitializeComponent();
        }
Ejemplo n.º 2
0
        /// <summary>
        /// ダイアログを生成する
        /// </summary>
        private static void _OpenDialog(Window owner, BindableTextEditor editor, TreeView tree, bool isFind)
        {
            _Dialog = new FindReplaceDialog(editor, tree);

            if (isFind)
            {
                _Dialog.findTab.IsSelected = true;
            }
            else
            {
                _Dialog.replaceTab.IsSelected = true;
            }

            _Dialog.Owner = owner;
            _Dialog.Show();
        }
Ejemplo n.º 3
0
        /// <summary>
        /// ダイアログを表示
        /// </summary>
        /// <param name="owner"></param>
        /// <param name="editor"></param>
        /// <param name="isFind"></param>
        public static void ShowFindReplaceDialog(Window owner, BindableTextEditor editor, TreeView tree, bool isFind)
        {
            if (_Dialog == null)
            {
                _OpenDialog(owner, editor, tree, isFind);
            }
            else
            {
                if (isFind)
                {
                    _Dialog.findTab.IsSelected = true;
                }
                else
                {
                    _Dialog.replaceTab.IsSelected = true;
                }
            }
            _Dialog.Activate();

            if (!string.IsNullOrEmpty(editor.TextArea.Selection.GetText()) &&
                !editor.TextArea.Selection.IsMultiline)
            {
                _Dialog.txtFind.Text  = editor.TextArea.Selection.GetText();
                _Dialog.txtFind2.Text = editor.TextArea.Selection.GetText();
            }

            if (isFind)
            {
                _Dialog.txtFind.SelectAll();
                _Dialog.txtFind.Focus();
            }
            else
            {
                _Dialog.txtFind2.SelectAll();
                _Dialog.txtFind2.Focus();
            }
        }
Ejemplo n.º 4
0
        /// <summary>
        /// FindReplaceDialogViewModel
        /// </summary>
        public FindReplaceDialogViewModel(Search model, BindableTextEditor editor)
        {
            this.Model  = model;
            this.Editor = editor;

            // プロパティの設定
            this.TextToFind = this.Model
                              .ToReactivePropertyAsSynchronized(x => x.TextToFind)
                              .AddTo(this.Disposable);

            this.TextToReplace = this.Model
                                 .ToReactivePropertyAsSynchronized(x => x.TextToReplace)
                                 .AddTo(this.Disposable);

            this.CaseSensitive = this.Model
                                 .ToReactivePropertyAsSynchronized(x => x.CaseSensitive)
                                 .AddTo(this.Disposable);

            this.WholeWord = this.Model
                             .ToReactivePropertyAsSynchronized(x => x.WholeWord)
                             .AddTo(this.Disposable);

            this.UseRegex = this.Model
                            .ToReactivePropertyAsSynchronized(x => x.UseRegex)
                            .AddTo(this.Disposable);

            this.UseWildcards = this.Model
                                .ToReactivePropertyAsSynchronized(x => x.UseWildcards)
                                .AddTo(this.Disposable);

            this.WholeAllNode = this.Model
                                .ToReactivePropertyAsSynchronized(x => x.WholeAllNode)
                                .AddTo(this.Disposable);

            this.HilightText = this.Model
                               .ToReactivePropertyAsSynchronized(x => x.HilightText)
                               .AddTo(this.Disposable);

            // コマンドの設定
            this.FindNextCommand = this.TextToFind
                                   .Select(x => !string.IsNullOrEmpty(x))
                                   .ToReactiveCommand();

            this.FindNextCommand.Subscribe(_ =>
            {
                this.Model.FindNext(this.Editor.SelectionStart, this.Editor.SelectionLength, false);
            }).AddTo(this.Disposable);

            this.FindPrevCommand = this.TextToFind
                                   .Select(x => !string.IsNullOrEmpty(x))
                                   .ToReactiveCommand();

            this.FindPrevCommand.Subscribe(_ =>
            {
                if (this.Editor.IsSelected)
                {
                    this.Model.FindNext(this.Editor.SelectionStart, this.Editor.SelectionLength, true);
                }
                else
                {
                    this.Model.FindNext(this.Editor.Text.Length, 0, true);
                }
            }).AddTo(this.Disposable);

            this.ReplaceCommand = new[] {
                this.TextToFind.Select(x => !string.IsNullOrEmpty(x))
            }
            .CombineLatestValuesAreAllTrue()
            .ToReactiveCommand();

            this.ReplaceCommand.Subscribe(_ =>
            {
                this.Model.Replace(this.Editor.SelectionStart, this.Editor.SelectionLength, this.Editor.IsSelected);
            }).AddTo(this.Disposable);


            this.ReplaceAllCommand = new[] {
                this.TextToFind.Select(x => !string.IsNullOrEmpty(x))
            }
            .CombineLatestValuesAreAllTrue()
            .ToReactiveCommand();

            this.ReplaceAllCommand.Subscribe(_ =>
            {
                this.Model.ReplaceAll();
            }).AddTo(this.Disposable);

            this.Model.Found.Subscribe(entity =>
            {
                this._ShowSearchResultRequest.Raise(new Confirmation
                {
                    Content = entity
                });
            })
            .AddTo(this.Disposable);

            this.Model.Confirmation.Subscribe(async tuple =>
            {
                var arg = new DialogArg()
                {
                    Title    = "確認",
                    Style    = MahApps.Metro.Controls.Dialogs.MessageDialogStyle.AffirmativeAndNegative,
                    Message  = tuple.Item1,
                    Settings = new MahApps.Metro.Controls.Dialogs.MetroDialogSettings()
                    {
                        AffirmativeButtonText = "置換",
                        NegativeButtonText    = "キャンセル",
                        DefaultButtonFocus    = MahApps.Metro.Controls.Dialogs.MessageDialogResult.Negative
                    }
                };

                await this._ShowDialogRequest.RaiseAsync(new Confirmation
                {
                    Content = arg
                });

                tuple.Item2(arg.Result == MahApps.Metro.Controls.Dialogs.MessageDialogResult.Affirmative);
            })
            .AddTo(this.Disposable);

            this.Model.FoundAll.Subscribe(List =>
            {
                this._SearchResultHighlightRequest.Raise(new Confirmation
                {
                    Content = List
                });
            })
            .AddTo(this.Disposable);
        }