Exemple #1
0
 public DialogResult(ButtonResult result, IDialogParameters parameters)
 {
     Result     = result;
     Parameters = parameters;
 }
 public void OnDialogOpened(IDialogParameters parameters)
 {
 }
 /// <summary>ダイアログOpen時のイベントハンドラ。</summary>
 /// <param name="parameters">IDialogServiceに設定されたパラメータを表すIDialogParameters。</param>
 public void OnDialogOpened(IDialogParameters parameters)
 {
     this.Message.Value = parameters.GetValue <string>("Message");
 }
Exemple #4
0
 void IDialogAware.OnDialogOpened(IDialogParameters parameters)
 {
 }
Exemple #5
0
        public void ShowDialog(string name, IDialogParameters parameters, Action <IDialogResult> callback)
        {
            try
            {
                parameters = UriParsingHelper.GetSegmentParameters(name, parameters);

                var view = CreateViewFor(UriParsingHelper.GetSegmentName(name));

                var dialogAware = InitializeDialog(view, parameters);
                var currentPage = GetCurrentPage();

                dialogAware.RequestClose += DialogAware_RequestClose;

                void DialogAware_RequestClose(IDialogParameters outParameters)
                {
                    try
                    {
                        var result = CloseDialog(outParameters ?? new DialogParameters(), currentPage);
                        if (result.Exception is DialogException de && de.Message == DialogException.CanCloseIsFalse)
                        {
                            return;
                        }

                        dialogAware.RequestClose -= DialogAware_RequestClose;
                        callback(result);
                        GC.Collect();
                    }
                    catch (DialogException dex)
                    {
                        if (dex.Message != DialogException.CanCloseIsFalse)
                        {
                            callback(new DialogResult
                            {
                                Exception  = dex,
                                Parameters = parameters
                            });
                        }
                    }
                    catch (Exception ex)
                    {
                        callback(new DialogResult
                        {
                            Exception  = ex,
                            Parameters = parameters
                        });
                    }
                }

                parameters.TryGetValue <bool>(KnownDialogParameters.CloseOnBackgroundTapped, out var hideOnBackgroundTapped);
                InsertPopupViewInCurrentPage(currentPage as ContentPage, view, hideOnBackgroundTapped, DialogAware_RequestClose);

                PageUtilities.InvokeViewAndViewModelAction <IActiveAware>(currentPage, aa => aa.IsActive = false);
                PageUtilities.InvokeViewAndViewModelAction <IActiveAware>(view, aa => aa.IsActive        = true);
            }
            catch (Exception ex)
            {
                var error = ex.ToString();
                callback(new DialogResult {
                    Exception = ex
                });
            }
        }
        /// <summary>
        /// Displays a dialog asynchronously.
        /// </summary>
        /// <param name="dialogService">The dialog service.</param>
        /// <param name="name">The unique name of the dialog to display. Must match an entry in the <see cref="IContainerRegistry"/>.</param>
        /// <param name="parameters">Parameters that the dialog can use for custom functionality.</param>
        /// <returns><see cref="IDialogResult"/> indicating whether the request was successful or if there was an encountered <see cref="Exception"/>.</returns>
        public static Task <IDialogResult> ShowDialogAsync(this IDialogService dialogService, string name, IDialogParameters parameters = null)
        {
            var tcs = new TaskCompletionSource <IDialogResult>();

            void DialogCallback(IDialogResult dialogResult)
            {
                tcs.SetResult(dialogResult);
            }

            dialogService.ShowDialog(name, parameters, DialogCallback);
            return(tcs.Task);
        }
Exemple #7
0
 public override void OnDialogOpened(IDialogParameters parameters)
 {
     base.OnDialogOpened(parameters);
     Title = parameters.GetValue <string>(DialogParams.Title);
 }
 public void OnDialogOpened(IDialogParameters parameters)
 {
     Weights = parameters.GetValue <ObservableCollection <IWeightViewModel> >(nameof(Weights));
 }
        /// <summary>モーダルダイアログを表示します。</summary>
        /// <param name="dlgService">対象のIDialogServiceを表します。</param>
        /// <param name="dialogViewName">表示するダイアログのView名を表す文字列。</param>
        /// <param name="parameters">ダイアログに渡すパラメータを表すIDialogParameters。</param>
        /// <returns>ダイアログの戻り値を表すIDialogResult。</returns>
        public static IDialogResult ShowDialog(this IDialogService dlgService, string dialogViewName, IDialogParameters parameters)
        {
            IDialogResult ret = null;

            dlgService.ShowDialog(dialogViewName, parameters, r => ret = r);

            return(ret);
        }
 public void OnDialogOpened(IDialogParameters parameters)
 {
     ListSaveTextBox = parameters.GetValue <string>(nameof(ListSaveTextBox));
 }
Exemple #11
0
 public void OnDialogOpened(IDialogParameters parameters)
 {
     this.Messege = parameters.GetValue <string>("Messege");
     //throw new NotImplementedException();
 }
Exemple #12
0
 public void OnDialogOpened(IDialogParameters parameters)
 {
     LoadHeaders();
 }
 /// <inheritdoc />
 public virtual void OnDialogOpened(IDialogParameters parameters)
 {
     this.RequestClose += this.OnDialogClosing;
 }
 public void Show(string name, IDialogParameters parameters, Action <IDialogResult> callback, bool hasOwner)
 {
     ShowDialogInternal(name, parameters, callback, false, hasOwner);
 }
 public virtual void OnDialogOpened(IDialogParameters parameters)        //удалить потом
 {
 }
        public void ShowDialog(string name, IDialogParameters parameters, Action <IDialogResult> callback)
        {
            try
            {
                parameters = UriParsingHelper.GetSegmentParameters(name, parameters);

                var view      = CreateViewFor(UriParsingHelper.GetSegmentName(name));
                var popupPage = CreatePopupPageForView(view);

                var dialogAware = InitializeDialog(view, parameters);

                if (!parameters.TryGetValue <bool>(KnownDialogParameters.CloseOnBackgroundTapped, out var closeOnBackgroundTapped))
                {
                    var dialogLayoutCloseOnBackgroundTapped = DialogLayout.GetCloseOnBackgroundTapped(view);
                    if (dialogLayoutCloseOnBackgroundTapped.HasValue)
                    {
                        closeOnBackgroundTapped = dialogLayoutCloseOnBackgroundTapped.Value;
                    }
                }

                dialogAware.RequestClose += DialogAware_RequestClose;

                void CloseOnBackgroundClicked(object sender, EventArgs args)
                {
                    DialogAware_RequestClose(new DialogParameters());
                }

                void DialogAware_RequestClose(IDialogParameters outParameters)
                {
                    try
                    {
                        var result = CloseDialog(outParameters ?? new DialogParameters(), popupPage, view);
                        if (result.Exception is DialogException de && de.Message == DialogException.CanCloseIsFalse)
                        {
                            return;
                        }

                        dialogAware.RequestClose -= DialogAware_RequestClose;
                        if (closeOnBackgroundTapped)
                        {
                            popupPage.BackgroundClicked -= CloseOnBackgroundClicked;
                        }
                        callback?.Invoke(result);
                        GC.Collect();
                    }
                    catch (DialogException dex)
                    {
                        if (dex.Message != DialogException.CanCloseIsFalse)
                        {
                            callback?.Invoke(new DialogResult
                            {
                                Exception  = dex,
                                Parameters = parameters
                            });
                        }
                    }
                    catch (Exception ex)
                    {
                        callback?.Invoke(new DialogResult
                        {
                            Exception  = ex,
                            Parameters = parameters
                        });
                    }
                }

                if (closeOnBackgroundTapped)
                {
                    popupPage.BackgroundClicked += CloseOnBackgroundClicked;
                }

                PushPopupPage(popupPage, view);
            }
            catch (Exception ex)
            {
                callback?.Invoke(new DialogResult {
                    Exception = ex
                });
            }
        }
 /// <summary>
 /// Displays a dialog.
 /// </summary>
 /// <param name="dialogService">The dialog service.</param>
 /// <param name="name">The unique name of the dialog to display. Must match an entry in the <see cref="IContainerRegistry"/>.</param>
 /// <param name="parameters">Parameters that the dialog can use for custom functionality.</param>
 public static void ShowDialog(this IDialogService dialogService, string name, IDialogParameters parameters) =>
 dialogService.ShowDialog(name, parameters, null);
 public void Show(string name, IDialogParameters parameters, Action <IDialogResult> callback, string windowName)
 {
     ShowDialogInternal(name, parameters, callback, false, windowName);
 }
Exemple #19
0
 public void ShowDialog(string name, IDialogParameters parameters, Action <IDialogResult> callback)
 {
     ShowDialogInternal(name, parameters, callback, true);
 }
        protected virtual void ConfigureDialogWindowContent(string dialogName, IDialogWindow window, IDialogParameters parameters)
        {
            var content       = _containerExtension.Resolve <object>(dialogName);
            var dialogContent = content as FrameworkElement;

            if (dialogContent == null)
            {
                throw new NullReferenceException("A dialog's content must be a FrameworkElement");
            }

            var viewModel = dialogContent.DataContext as IDialogAware;

            if (viewModel == null)
            {
                throw new NullReferenceException("A dialog's ViewModel must implement the IDialogAware interface");
            }

            ConfigureDialogWindowProperties(window, dialogContent, viewModel);

            MvvmHelpers.ViewAndViewModelAction <IDialogAware>(viewModel, d => d.OnDialogOpened(parameters));
        }
Exemple #21
0
 public virtual Task OnDialogOpenedAsync(IDialogParameters parameters)
 {
     return(Task.FromResult(true));
 }
Exemple #22
0
 public void Show(string name, IDialogParameters parameters, Action <IDialogResult> callback)
 {
     CommonShow(name, parameters, callback, false);
 }
 public void OnDialogOpened(IDialogParameters parameters)
 {
     ProductFilter = parameters.GetValue <ProductsFilterModel>("ProductsFilterModel");
 }
 private void RaiseRequestClose(ButtonResult dialogResult, IDialogParameters dialogParameters)
 => RequestClose?.Invoke(new DialogResult(dialogResult, dialogParameters));
Exemple #25
0
 public void OnDialogOpened(IDialogParameters parameters)
 {
     ModelPath.Value  = parameters.GetValue <string>("strModelPath");
     MotionPath.Value = parameters.GetValue <string>("strMotionPath");
     // ここに表示させるための処理を記述
 }
Exemple #26
0
 public void ShowDialog(string _name, IDialogParameters _parameters, Action <IDialogResult> _callback)
 {
     _callback.Invoke(new DialogResult());
 }
Exemple #27
0
 public void OnDialogOpened(IDialogParameters parameters)
 {
     Message = parameters.GetValue <string>("message");
 }
 public void OnDialogOpened(IDialogParameters parameters)
 {
     throw new NotImplementedException();
 }
Exemple #29
0
 public void OnDialogOpened(IDialogParameters parameters)
 {
     Message = parameters.GetValue <string>(nameof(Message));
 }
 public void ShowDialog(string name, IDialogParameters parameters, Action <IDialogResult> callback)
 {
     throw new NotImplementedException();
 }