コード例 #1
0
            public HResult SetFlags(NiTaskDialogFlags flags)
            {
                try
                {
                    _taskDialog.EnableHyperlinks         = flags.HasFlag(NiTaskDialogFlags.EnableHyperlinks);
                    _taskDialog.AllowDialogCancellation  = flags.HasFlag(NiTaskDialogFlags.AllowDialogCancellation);
                    _taskDialog.UseCommandLinks          = flags.HasFlag(NiTaskDialogFlags.UseCommandLinks);
                    _taskDialog.UseCommandLinksNoIcon    = flags.HasFlag(NiTaskDialogFlags.UseCommandLinksNoIcon);
                    _taskDialog.ExpandFooterArea         = flags.HasFlag(NiTaskDialogFlags.ExpandFooterArea);
                    _taskDialog.ExpandedByDefault        = flags.HasFlag(NiTaskDialogFlags.ExpandedByDefault);
                    _taskDialog.VerificationFlagChecked  = flags.HasFlag(NiTaskDialogFlags.VerificationFlagChecked);
                    _taskDialog.ShowProgressBar          = flags.HasFlag(NiTaskDialogFlags.ShowProgressBar);
                    _taskDialog.ShowMarqueeProgressBar   = flags.HasFlag(NiTaskDialogFlags.ShowMarqueeProgressBar);
                    _taskDialog.CallbackTimer            = flags.HasFlag(NiTaskDialogFlags.CallbackTimer);
                    _taskDialog.PositionRelativeToWindow = flags.HasFlag(NiTaskDialogFlags.PositionRelativeToWindow);
                    _taskDialog.RightToLeftLayout        = flags.HasFlag(NiTaskDialogFlags.RightToLeftLayout);
                    _taskDialog.NoDefaultRadioButton     = flags.HasFlag(NiTaskDialogFlags.NoDefaultRadioButton);
                    _taskDialog.CanBeMinimized           = flags.HasFlag(NiTaskDialogFlags.CanBeMinimized);

                    return(HResult.OK);
                }
                catch (Exception ex)
                {
                    return(ErrorUtil.GetHResult(ex));
                }
            }
コード例 #2
0
ファイル: NiTaskDialogBuilder.cs プロジェクト: netide/netide
        public void Alert(IWin32Window owner)
        {
            if (!_mainIcon.HasValue)
                _mainIcon = NiTaskDialogIcon.Error;
            if (!_commonButtons.HasValue)
                _commonButtons = NiTaskDialogCommonButtons.OK;

            _flags |= NiTaskDialogFlags.AllowDialogCancellation;

            Show(owner);
        }
コード例 #3
0
        public void Alert(IWin32Window owner)
        {
            if (!_mainIcon.HasValue)
            {
                _mainIcon = NiTaskDialogIcon.Error;
            }
            if (!_commonButtons.HasValue)
            {
                _commonButtons = NiTaskDialogCommonButtons.OK;
            }

            _flags |= NiTaskDialogFlags.AllowDialogCancellation;

            Show(owner);
        }
コード例 #4
0
        public NiTaskDialogBuilder FromException(Exception exception)
        {
            if (exception == null)
            {
                throw new ArgumentNullException("exception");
            }

            _content             = String.Format(Labels.UnexpectedSituationMessage, exception.Message);
            _expandedControlText = Labels.UnexpectedSituationShowStackTrace;
            _expandedInformation = GetExceptionLog(exception);
            _mainIcon            = NiTaskDialogIcon.Error;
            _commonButtons       = NiTaskDialogCommonButtons.OK;
            _flags |= NiTaskDialogFlags.AllowDialogCancellation;

            return(this);
        }
コード例 #5
0
ファイル: NiTaskDialogBuilder.cs プロジェクト: netide/netide
        public NiTaskDialogBuilder FromException(Exception exception)
        {
            if (exception == null)
                throw new ArgumentNullException("exception");

            _content = String.Format(Labels.UnexpectedSituationMessage, exception.Message);
            _expandedControlText = Labels.UnexpectedSituationShowStackTrace;
            _expandedInformation = GetExceptionLog(exception);
            _mainIcon = NiTaskDialogIcon.Error;
            _commonButtons = NiTaskDialogCommonButtons.OK;
            _flags |= NiTaskDialogFlags.AllowDialogCancellation;

            return this;
        }
コード例 #6
0
ファイル: NiShell.TaskDialog.cs プロジェクト: netide/netide
            public HResult SetFlags(NiTaskDialogFlags flags)
            {
                try
                {
                    _taskDialog.EnableHyperlinks = flags.HasFlag(NiTaskDialogFlags.EnableHyperlinks);
                    _taskDialog.AllowDialogCancellation = flags.HasFlag(NiTaskDialogFlags.AllowDialogCancellation);
                    _taskDialog.UseCommandLinks = flags.HasFlag(NiTaskDialogFlags.UseCommandLinks);
                    _taskDialog.UseCommandLinksNoIcon = flags.HasFlag(NiTaskDialogFlags.UseCommandLinksNoIcon);
                    _taskDialog.ExpandFooterArea = flags.HasFlag(NiTaskDialogFlags.ExpandFooterArea);
                    _taskDialog.ExpandedByDefault = flags.HasFlag(NiTaskDialogFlags.ExpandedByDefault);
                    _taskDialog.VerificationFlagChecked = flags.HasFlag(NiTaskDialogFlags.VerificationFlagChecked);
                    _taskDialog.ShowProgressBar = flags.HasFlag(NiTaskDialogFlags.ShowProgressBar);
                    _taskDialog.ShowMarqueeProgressBar = flags.HasFlag(NiTaskDialogFlags.ShowMarqueeProgressBar);
                    _taskDialog.CallbackTimer = flags.HasFlag(NiTaskDialogFlags.CallbackTimer);
                    _taskDialog.PositionRelativeToWindow = flags.HasFlag(NiTaskDialogFlags.PositionRelativeToWindow);
                    _taskDialog.RightToLeftLayout = flags.HasFlag(NiTaskDialogFlags.RightToLeftLayout);
                    _taskDialog.NoDefaultRadioButton = flags.HasFlag(NiTaskDialogFlags.NoDefaultRadioButton);
                    _taskDialog.CanBeMinimized = flags.HasFlag(NiTaskDialogFlags.CanBeMinimized);

                    return HResult.OK;
                }
                catch (Exception ex)
                {
                    return ErrorUtil.GetHResult(ex);
                }
            }
コード例 #7
0
ファイル: NiShell.TaskDialog.cs プロジェクト: netide/netide
            public HResult GetFlags(out NiTaskDialogFlags flags)
            {
                flags = 0;

                try
                {
                    if (_taskDialog.EnableHyperlinks)
                        flags |= NiTaskDialogFlags.EnableHyperlinks;
                    if (_taskDialog.AllowDialogCancellation)
                        flags |= NiTaskDialogFlags.AllowDialogCancellation;
                    if (_taskDialog.UseCommandLinks)
                        flags |= NiTaskDialogFlags.UseCommandLinks;
                    if (_taskDialog.UseCommandLinksNoIcon)
                        flags |= NiTaskDialogFlags.UseCommandLinksNoIcon;
                    if (_taskDialog.ExpandFooterArea)
                        flags |= NiTaskDialogFlags.ExpandFooterArea;
                    if (_taskDialog.ExpandedByDefault)
                        flags |= NiTaskDialogFlags.ExpandedByDefault;
                    if (_taskDialog.VerificationFlagChecked)
                        flags |= NiTaskDialogFlags.VerificationFlagChecked;
                    if (_taskDialog.ShowProgressBar)
                        flags |= NiTaskDialogFlags.ShowProgressBar;
                    if (_taskDialog.ShowMarqueeProgressBar)
                        flags |= NiTaskDialogFlags.ShowMarqueeProgressBar;
                    if (_taskDialog.CallbackTimer)
                        flags |= NiTaskDialogFlags.CallbackTimer;
                    if (_taskDialog.PositionRelativeToWindow)
                        flags |= NiTaskDialogFlags.PositionRelativeToWindow;
                    if (_taskDialog.RightToLeftLayout)
                        flags |= NiTaskDialogFlags.RightToLeftLayout;
                    if (_taskDialog.NoDefaultRadioButton)
                        flags |= NiTaskDialogFlags.NoDefaultRadioButton;
                    if (_taskDialog.CanBeMinimized)
                        flags |= NiTaskDialogFlags.CanBeMinimized;

                    return HResult.OK;
                }
                catch (Exception ex)
                {
                    return ErrorUtil.GetHResult(ex);
                }
            }
コード例 #8
0
            public HResult GetFlags(out NiTaskDialogFlags flags)
            {
                flags = 0;

                try
                {
                    if (_taskDialog.EnableHyperlinks)
                    {
                        flags |= NiTaskDialogFlags.EnableHyperlinks;
                    }
                    if (_taskDialog.AllowDialogCancellation)
                    {
                        flags |= NiTaskDialogFlags.AllowDialogCancellation;
                    }
                    if (_taskDialog.UseCommandLinks)
                    {
                        flags |= NiTaskDialogFlags.UseCommandLinks;
                    }
                    if (_taskDialog.UseCommandLinksNoIcon)
                    {
                        flags |= NiTaskDialogFlags.UseCommandLinksNoIcon;
                    }
                    if (_taskDialog.ExpandFooterArea)
                    {
                        flags |= NiTaskDialogFlags.ExpandFooterArea;
                    }
                    if (_taskDialog.ExpandedByDefault)
                    {
                        flags |= NiTaskDialogFlags.ExpandedByDefault;
                    }
                    if (_taskDialog.VerificationFlagChecked)
                    {
                        flags |= NiTaskDialogFlags.VerificationFlagChecked;
                    }
                    if (_taskDialog.ShowProgressBar)
                    {
                        flags |= NiTaskDialogFlags.ShowProgressBar;
                    }
                    if (_taskDialog.ShowMarqueeProgressBar)
                    {
                        flags |= NiTaskDialogFlags.ShowMarqueeProgressBar;
                    }
                    if (_taskDialog.CallbackTimer)
                    {
                        flags |= NiTaskDialogFlags.CallbackTimer;
                    }
                    if (_taskDialog.PositionRelativeToWindow)
                    {
                        flags |= NiTaskDialogFlags.PositionRelativeToWindow;
                    }
                    if (_taskDialog.RightToLeftLayout)
                    {
                        flags |= NiTaskDialogFlags.RightToLeftLayout;
                    }
                    if (_taskDialog.NoDefaultRadioButton)
                    {
                        flags |= NiTaskDialogFlags.NoDefaultRadioButton;
                    }
                    if (_taskDialog.CanBeMinimized)
                    {
                        flags |= NiTaskDialogFlags.CanBeMinimized;
                    }

                    return(HResult.OK);
                }
                catch (Exception ex)
                {
                    return(ErrorUtil.GetHResult(ex));
                }
            }
コード例 #9
0
ファイル: NiTaskDialog.cs プロジェクト: vector-man/netide
        public DialogResult ShowDialog(IWin32Window owner, IServiceProvider serviceProvider)
        {
            if (serviceProvider == null)
            {
                serviceProvider = ResolveSite();

                if (serviceProvider == null)
                {
                    throw new InvalidOperationException("Cannot resolve site");
                }
            }

            INiTaskDialog taskDialog;

            ErrorUtil.ThrowOnFailure(((INiShell)serviceProvider.GetService(typeof(INiShell))).CreateTaskDialog(
                                         out taskDialog
                                         ));

            NiTaskDialogFlags flags = 0;

            if (CanCancel)
            {
                flags |= NiTaskDialogFlags.AllowDialogCancellation;
            }
            if (CallbackTimer)
            {
                flags |= NiTaskDialogFlags.CallbackTimer;
            }
            if (CanMinimize)
            {
                flags |= NiTaskDialogFlags.CanBeMinimized;
            }
            if (EnableHyperlinks)
            {
                flags |= NiTaskDialogFlags.EnableHyperlinks;
            }
            if (ExpandedByDefault)
            {
                flags |= NiTaskDialogFlags.ExpandedByDefault;
            }
            if (NoDefaultRadioButton)
            {
                flags |= NiTaskDialogFlags.NoDefaultRadioButton;
            }
            if (CenterParent)
            {
                flags |= NiTaskDialogFlags.PositionRelativeToWindow;
            }
            if (VerificationFlagInitiallyChecked)
            {
                flags |= NiTaskDialogFlags.VerificationFlagChecked;
            }

            switch (RightToLeft)
            {
            case RightToLeft.Yes:
                flags |= NiTaskDialogFlags.RightToLeftLayout;
                break;

            case RightToLeft.Inherit:
                if (ContainerControl != null && ContainerControl.RightToLeft == RightToLeft.Yes)
                {
                    flags |= NiTaskDialogFlags.RightToLeftLayout;
                }
                break;
            }

            switch (ProgressBar)
            {
            case NiTaskDialogProgressBarStyle.Normal:
                flags |= NiTaskDialogFlags.ShowProgressBar;
                break;

            case NiTaskDialogProgressBarStyle.Marquee:
                flags |= NiTaskDialogFlags.ShowProgressBar | NiTaskDialogFlags.ShowMarqueeProgressBar;
                break;
            }

            switch (ButtonStyle)
            {
            case NiTaskDialogButtonStyle.CommandLink:
                flags |= NiTaskDialogFlags.UseCommandLinks;
                break;

            case NiTaskDialogButtonStyle.CommandLinkWithoutIcon:
                flags |= NiTaskDialogFlags.UseCommandLinks | NiTaskDialogFlags.UseCommandLinksNoIcon;
                break;
            }

            if (ExpandedInformationLocation == NiTaskDialogExpandedInformationLocation.Bottom)
            {
                flags |= NiTaskDialogFlags.ExpandFooterArea;
            }

            ErrorUtil.ThrowOnFailure(taskDialog.SetFlags(flags));

            ErrorUtil.ThrowOnFailure(taskDialog.SetCommonButtons(CommonButtons));

            if (MainIcon != 0)
            {
                ErrorUtil.ThrowOnFailure(taskDialog.SetMainIcon(MainIcon));
            }
            if (CustomMainIcon != null)
            {
                ErrorUtil.ThrowOnFailure(taskDialog.SetMainIcon(CustomMainIcon));
            }
            if (FooterIcon != 0)
            {
                ErrorUtil.ThrowOnFailure(taskDialog.SetFooterIcon(FooterIcon));
            }
            if (CustomFooterIcon != null)
            {
                ErrorUtil.ThrowOnFailure(taskDialog.SetFooterIcon(CustomFooterIcon));
            }

            _buttons.Clear();

            bool hadDefault = false;

            foreach (var button in Buttons)
            {
                var id = AddButton(_buttons, button);
                ErrorUtil.ThrowOnFailure(taskDialog.AddButton(
                                             id,
                                             button.FormattedText
                                             ));

                if (!hadDefault && button.Default)
                {
                    hadDefault = true;
                    ErrorUtil.ThrowOnFailure(taskDialog.SetDefaultButton(id));
                }
            }

            hadDefault = false;

            foreach (var button in RadioButtons)
            {
                var id = AddButton(_buttons, button);
                ErrorUtil.ThrowOnFailure(taskDialog.AddRadioButton(
                                             id,
                                             button.FormattedText
                                             ));

                if (!hadDefault && button.Default)
                {
                    hadDefault = true;
                    ErrorUtil.ThrowOnFailure(taskDialog.SetDefaultRadioButton(id));
                }
            }

            if (Width != 0)
            {
                ErrorUtil.ThrowOnFailure(taskDialog.SetWidth(Width));
            }

            string collapsedControlText = _collapsedControlText.Formatted;

            if (collapsedControlText.Length > 0)
            {
                ErrorUtil.ThrowOnFailure(taskDialog.SetCollapsedControlText(collapsedControlText));
            }
            string content = _content.Formatted;

            if (content.Length > 0)
            {
                ErrorUtil.ThrowOnFailure(taskDialog.SetContent(content));
            }
            string expandedControlText = _expandedControlText.Formatted;

            if (expandedControlText.Length > 0)
            {
                ErrorUtil.ThrowOnFailure(taskDialog.SetExpandedControlText(expandedControlText));
            }
            string expandedInformation = _expandedInformation.Formatted;

            if (expandedInformation.Length > 0)
            {
                ErrorUtil.ThrowOnFailure(taskDialog.SetExpandedInformation(expandedInformation));
            }
            string footerText = _footerText.Formatted;

            if (footerText.Length > 0)
            {
                ErrorUtil.ThrowOnFailure(taskDialog.SetFooter(footerText));
            }
            string mainInstruction = _mainInstruction.Formatted;

            if (mainInstruction.Length > 0)
            {
                ErrorUtil.ThrowOnFailure(taskDialog.SetMainInstruction(mainInstruction));
            }
            string verificationText = _verificationText.Formatted;

            if (verificationText.Length > 0)
            {
                ErrorUtil.ThrowOnFailure(taskDialog.SetVerificationText(verificationText));
            }
            string windowTitle = _windowTitle.Formatted;

            if (windowTitle.Length > 0)
            {
                ErrorUtil.ThrowOnFailure(taskDialog.SetWindowTitle(windowTitle));
            }

            new Notify(this, taskDialog);

            bool verificationFlagChecked;
            int  radioButtonClicked;
            int  result;

            ErrorUtil.ThrowOnFailure(taskDialog.Show(
                                         owner == null ? IntPtr.Zero : owner.Handle,
                                         out verificationFlagChecked,
                                         out radioButtonClicked,
                                         out result
                                         ));

            VerificationFlagChecked = verificationFlagChecked;

            SelectedButton      = FindButton(result);
            SelectedRadioButton = FindButton(radioButtonClicked);

            if (SelectedButton != null)
            {
                return(SelectedButton.DialogResult);
            }

            return((DialogResult)result);
        }