using System;
using System.Diagnostics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;

[assembly: AssemblyDescription("Accessibility.dll")]
[assembly: ComVisible(true)]
[assembly: CLSCompliant(true)]
[assembly: AllowPartiallyTrustedCallers]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: ImportedFromTypeLib("Accessibility")]
[assembly: AssemblyFileVersion("4.7.3056.0")]
[assembly: AssemblyTitle("Accessibility.dll")]
[assembly: CompilationRelaxations(8)]
[assembly: AssemblyProduct("Microsoft® .NET Framework")]
[assembly: AssemblyDefaultAlias("Accessibility.dll")]
[assembly: SatelliteContractVersion("4.0.0.0")]
[assembly: AssemblyCompany("Microsoft Corporation")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: TypeLibVersion(1, 1)]
[assembly: AssemblyCopyright("© Microsoft Corporation.  All rights reserved.")]
[assembly: DefaultDllImportSearchPaths(DllImportSearchPath.System32 | DllImportSearchPath.AssemblyDirectory)]
[assembly: SecurityRules(SecurityRuleSet.Level2, SkipVerificationInFullTrust = true)]
[assembly: AssemblyDelaySign(true)]
[assembly: Guid("1EA4DBF0-3C3B-11CF-810C-00AA00389B71")]
[assembly: AssemblyInformationalVersion("4.7.3056.0")]
[assembly: AssemblyKeyFile("f:\\dd\\tools\\devdiv\\FinalPublicKey.snk")]
[assembly: AssemblyVersion("4.0.0.0")]
namespace Accessibility;

[ComImport]
[ComConversionLoss]
[Guid("6E26E776-04F0-495D-80E4-3330352E3169")]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IAccPropServices
{
	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	void SetPropValue([In] ref byte pIDString, [In] uint dwIDStringLen, [In] Guid idProp, [In][MarshalAs(UnmanagedType.Struct)] object var);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	void SetPropServer([In] ref byte pIDString, [In] uint dwIDStringLen, [In] ref Guid paProps, [In] int cProps, [In][MarshalAs(UnmanagedType.Interface)] IAccPropServer pServer, [In] AnnoScope AnnoScope);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	void ClearProps([In] ref byte pIDString, [In] uint dwIDStringLen, [In] ref Guid paProps, [In] int cProps);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	void SetHwndProp([In][ComAliasName("Accessibility.wireHWND")] ref _RemotableHandle hwnd, [In] uint idObject, [In] uint idChild, [In] Guid idProp, [In][MarshalAs(UnmanagedType.Struct)] object var);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	void SetHwndPropStr([In][ComAliasName("Accessibility.wireHWND")] ref _RemotableHandle hwnd, [In] uint idObject, [In] uint idChild, [In] Guid idProp, [In][MarshalAs(UnmanagedType.LPWStr)] string str);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	void SetHwndPropServer([In][ComAliasName("Accessibility.wireHWND")] ref _RemotableHandle hwnd, [In] uint idObject, [In] uint idChild, [In] ref Guid paProps, [In] int cProps, [In][MarshalAs(UnmanagedType.Interface)] IAccPropServer pServer, [In] AnnoScope AnnoScope);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	void ClearHwndProps([In][ComAliasName("Accessibility.wireHWND")] ref _RemotableHandle hwnd, [In] uint idObject, [In] uint idChild, [In] ref Guid paProps, [In] int cProps);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	void ComposeHwndIdentityString([In][ComAliasName("Accessibility.wireHWND")] ref _RemotableHandle hwnd, [In] uint idObject, [In] uint idChild, [Out] IntPtr ppIDString, out uint pdwIDStringLen);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	void DecomposeHwndIdentityString([In] ref byte pIDString, [In] uint dwIDStringLen, [Out][ComAliasName("Accessibility.wireHWND")] IntPtr phwnd, out uint pidObject, out uint pidChild);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	void SetHmenuProp([In][ComAliasName("Accessibility.wireHMENU")] ref _RemotableHandle hmenu, [In] uint idChild, [In] Guid idProp, [In][MarshalAs(UnmanagedType.Struct)] object var);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	void SetHmenuPropStr([In][ComAliasName("Accessibility.wireHMENU")] ref _RemotableHandle hmenu, [In] uint idChild, [In] Guid idProp, [In][MarshalAs(UnmanagedType.LPWStr)] string str);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	void SetHmenuPropServer([In][ComAliasName("Accessibility.wireHMENU")] ref _RemotableHandle hmenu, [In] uint idChild, [In] ref Guid paProps, [In] int cProps, [In][MarshalAs(UnmanagedType.Interface)] IAccPropServer pServer, [In] AnnoScope AnnoScope);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	void ClearHmenuProps([In][ComAliasName("Accessibility.wireHMENU")] ref _RemotableHandle hmenu, [In] uint idChild, [In] ref Guid paProps, [In] int cProps);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	void ComposeHmenuIdentityString([In][ComAliasName("Accessibility.wireHMENU")] ref _RemotableHandle hmenu, [In] uint idChild, [Out] IntPtr ppIDString, out uint pdwIDStringLen);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	void DecomposeHmenuIdentityString([In] ref byte pIDString, [In] uint dwIDStringLen, [Out][ComAliasName("Accessibility.wireHMENU")] IntPtr phmenu, out uint pidChild);
}
[ComImport]
[Guid("76C0DBBB-15E0-4E7B-B61B-20EEEA2001E0")]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IAccPropServer
{
	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	void GetPropValue([In] ref byte pIDString, [In] uint dwIDStringLen, [In] Guid idProp, [MarshalAs(UnmanagedType.Struct)] out object pvarValue, out int pfHasProp);
}
public enum AnnoScope
{
	ANNO_THIS,
	ANNO_CONTAINER
}
[StructLayout(LayoutKind.Sequential, Pack = 4)]
public struct _RemotableHandle
{
	public int fContext;

	public __MIDL_IWinTypes_0009 u;
}
[ComImport]
[Guid("6E26E776-04F0-495D-80E4-3330352E3169")]
[CoClass(typeof(CAccPropServicesClass))]
public interface CAccPropServices : IAccPropServices
{
}
[ComImport]
[Guid("B5F8350B-0548-48B1-A6EE-88BD00B4A5E7")]
[ClassInterface(ClassInterfaceType.None)]
[TypeLibType(TypeLibTypeFlags.FCanCreate)]
[ComConversionLoss]
public class CAccPropServicesClass : IAccPropServices, CAccPropServices
{
	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	public virtual extern void SetPropValue([In] ref byte pIDString, [In] uint dwIDStringLen, [In] Guid idProp, [In][MarshalAs(UnmanagedType.Struct)] object var);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	public virtual extern void SetPropServer([In] ref byte pIDString, [In] uint dwIDStringLen, [In] ref Guid paProps, [In] int cProps, [In][MarshalAs(UnmanagedType.Interface)] IAccPropServer pServer, [In] AnnoScope AnnoScope);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	public virtual extern void ClearProps([In] ref byte pIDString, [In] uint dwIDStringLen, [In] ref Guid paProps, [In] int cProps);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	public virtual extern void SetHwndProp([In][ComAliasName("Accessibility.wireHWND")] ref _RemotableHandle hwnd, [In] uint idObject, [In] uint idChild, [In] Guid idProp, [In][MarshalAs(UnmanagedType.Struct)] object var);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	public virtual extern void SetHwndPropStr([In][ComAliasName("Accessibility.wireHWND")] ref _RemotableHandle hwnd, [In] uint idObject, [In] uint idChild, [In] Guid idProp, [In][MarshalAs(UnmanagedType.LPWStr)] string str);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	public virtual extern void SetHwndPropServer([In][ComAliasName("Accessibility.wireHWND")] ref _RemotableHandle hwnd, [In] uint idObject, [In] uint idChild, [In] ref Guid paProps, [In] int cProps, [In][MarshalAs(UnmanagedType.Interface)] IAccPropServer pServer, [In] AnnoScope AnnoScope);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	public virtual extern void ClearHwndProps([In][ComAliasName("Accessibility.wireHWND")] ref _RemotableHandle hwnd, [In] uint idObject, [In] uint idChild, [In] ref Guid paProps, [In] int cProps);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	public virtual extern void ComposeHwndIdentityString([In][ComAliasName("Accessibility.wireHWND")] ref _RemotableHandle hwnd, [In] uint idObject, [In] uint idChild, [Out] IntPtr ppIDString, out uint pdwIDStringLen);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	public virtual extern void DecomposeHwndIdentityString([In] ref byte pIDString, [In] uint dwIDStringLen, [Out][ComAliasName("Accessibility.wireHWND")] IntPtr phwnd, out uint pidObject, out uint pidChild);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	public virtual extern void SetHmenuProp([In][ComAliasName("Accessibility.wireHMENU")] ref _RemotableHandle hmenu, [In] uint idChild, [In] Guid idProp, [In][MarshalAs(UnmanagedType.Struct)] object var);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	public virtual extern void SetHmenuPropStr([In][ComAliasName("Accessibility.wireHMENU")] ref _RemotableHandle hmenu, [In] uint idChild, [In] Guid idProp, [In][MarshalAs(UnmanagedType.LPWStr)] string str);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	public virtual extern void SetHmenuPropServer([In][ComAliasName("Accessibility.wireHMENU")] ref _RemotableHandle hmenu, [In] uint idChild, [In] ref Guid paProps, [In] int cProps, [In][MarshalAs(UnmanagedType.Interface)] IAccPropServer pServer, [In] AnnoScope AnnoScope);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	public virtual extern void ClearHmenuProps([In][ComAliasName("Accessibility.wireHMENU")] ref _RemotableHandle hmenu, [In] uint idChild, [In] ref Guid paProps, [In] int cProps);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	public virtual extern void ComposeHmenuIdentityString([In][ComAliasName("Accessibility.wireHMENU")] ref _RemotableHandle hmenu, [In] uint idChild, [Out] IntPtr ppIDString, out uint pdwIDStringLen);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	public virtual extern void DecomposeHmenuIdentityString([In] ref byte pIDString, [In] uint dwIDStringLen, [Out][ComAliasName("Accessibility.wireHMENU")] IntPtr phmenu, out uint pidChild);
}
[StructLayout(LayoutKind.Explicit, Pack = 4, Size = 4)]
public struct __MIDL_IWinTypes_0009
{
	[FieldOffset(0)]
	public int hInproc;

	[FieldOffset(0)]
	public int hRemote;
}
[ComImport]
[Guid("618736E0-3C3D-11CF-810C-00AA00389B71")]
[TypeLibType(TypeLibTypeFlags.FHidden | TypeLibTypeFlags.FDual | TypeLibTypeFlags.FDispatchable)]
public interface IAccessible
{
	[DispId(-5000)]
	object accParent
	{
		[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
		[TypeLibFunc(TypeLibFuncFlags.FHidden)]
		[DispId(-5000)]
		[return: MarshalAs(UnmanagedType.IDispatch)]
		get;
	}

	[DispId(-5001)]
	int accChildCount
	{
		[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
		[TypeLibFunc(TypeLibFuncFlags.FHidden)]
		[DispId(-5001)]
		get;
	}

	[DispId(-5002)]
	object accChild
	{
		[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
		[DispId(-5002)]
		[TypeLibFunc(TypeLibFuncFlags.FHidden)]
		[return: MarshalAs(UnmanagedType.IDispatch)]
		get;
	}

	[DispId(-5003)]
	string accName
	{
		[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
		[DispId(-5003)]
		[TypeLibFunc(TypeLibFuncFlags.FHidden)]
		[return: MarshalAs(UnmanagedType.BStr)]
		get;
		[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
		[TypeLibFunc(TypeLibFuncFlags.FHidden)]
		[DispId(-5003)]
		[param: In]
		[param: MarshalAs(UnmanagedType.BStr)]
		set;
	}

	[DispId(-5004)]
	string accValue
	{
		[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
		[DispId(-5004)]
		[TypeLibFunc(TypeLibFuncFlags.FHidden)]
		[return: MarshalAs(UnmanagedType.BStr)]
		get;
		[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
		[TypeLibFunc(TypeLibFuncFlags.FHidden)]
		[DispId(-5004)]
		[param: In]
		[param: MarshalAs(UnmanagedType.BStr)]
		set;
	}

	[DispId(-5005)]
	string accDescription
	{
		[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
		[DispId(-5005)]
		[TypeLibFunc(TypeLibFuncFlags.FHidden)]
		[return: MarshalAs(UnmanagedType.BStr)]
		get;
	}

	[DispId(-5006)]
	object accRole
	{
		[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
		[DispId(-5006)]
		[TypeLibFunc(TypeLibFuncFlags.FHidden)]
		[return: MarshalAs(UnmanagedType.Struct)]
		get;
	}

	[DispId(-5007)]
	object accState
	{
		[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
		[TypeLibFunc(TypeLibFuncFlags.FHidden)]
		[DispId(-5007)]
		[return: MarshalAs(UnmanagedType.Struct)]
		get;
	}

	[DispId(-5008)]
	string accHelp
	{
		[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
		[DispId(-5008)]
		[TypeLibFunc(TypeLibFuncFlags.FHidden)]
		[return: MarshalAs(UnmanagedType.BStr)]
		get;
	}

	[DispId(-5009)]
	int accHelpTopic
	{
		[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
		[DispId(-5009)]
		[TypeLibFunc(TypeLibFuncFlags.FHidden)]
		get;
	}

	[DispId(-5010)]
	string accKeyboardShortcut
	{
		[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
		[DispId(-5010)]
		[TypeLibFunc(TypeLibFuncFlags.FHidden)]
		[return: MarshalAs(UnmanagedType.BStr)]
		get;
	}

	[DispId(-5011)]
	object accFocus
	{
		[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
		[TypeLibFunc(TypeLibFuncFlags.FHidden)]
		[DispId(-5011)]
		[return: MarshalAs(UnmanagedType.Struct)]
		get;
	}

	[DispId(-5012)]
	object accSelection
	{
		[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
		[TypeLibFunc(TypeLibFuncFlags.FHidden)]
		[DispId(-5012)]
		[return: MarshalAs(UnmanagedType.Struct)]
		get;
	}

	[DispId(-5013)]
	string accDefaultAction
	{
		[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
		[TypeLibFunc(TypeLibFuncFlags.FHidden)]
		[DispId(-5013)]
		[return: MarshalAs(UnmanagedType.BStr)]
		get;
	}

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	[TypeLibFunc(TypeLibFuncFlags.FHidden)]
	[DispId(-5014)]
	void accSelect([In] int flagsSelect, [Optional][In][MarshalAs(UnmanagedType.Struct)] object varChild);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	[DispId(-5015)]
	[TypeLibFunc(TypeLibFuncFlags.FHidden)]
	void accLocation(out int pxLeft, out int pyTop, out int pcxWidth, out int pcyHeight, [Optional][In][MarshalAs(UnmanagedType.Struct)] object varChild);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	[TypeLibFunc(TypeLibFuncFlags.FHidden)]
	[DispId(-5016)]
	[return: MarshalAs(UnmanagedType.Struct)]
	object accNavigate([In] int navDir, [Optional][In][MarshalAs(UnmanagedType.Struct)] object varStart);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	[TypeLibFunc(TypeLibFuncFlags.FHidden)]
	[DispId(-5017)]
	[return: MarshalAs(UnmanagedType.Struct)]
	object accHitTest([In] int xLeft, [In] int yTop);

	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	[DispId(-5018)]
	[TypeLibFunc(TypeLibFuncFlags.FHidden)]
	void accDoDefaultAction([Optional][In][MarshalAs(UnmanagedType.Struct)] object varChild);
}
[ComImport]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
[TypeLibType(TypeLibTypeFlags.FHidden | TypeLibTypeFlags.FOleAutomation)]
[Guid("03022430-ABC4-11D0-BDE2-00AA001A1953")]
public interface IAccessibleHandler
{
	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	void AccessibleObjectFromID([In] int hwnd, [In] int lObjectID, [MarshalAs(UnmanagedType.Interface)] out IAccessible pIAccessible);
}
[ComImport]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
[Guid("7852B78D-1CFD-41C1-A615-9C0C85960B5F")]
[ComConversionLoss]
public interface IAccIdentity
{
	[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType = MethodCodeType.Runtime)]
	void GetIdentityString([In] uint dwIDChild, [Out] IntPtr ppIDString, out uint pdwIDStringLen);
}

using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Design;
using System.Drawing.Drawing2D;
using System.Globalization;
using System.IO;
using System.Net;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.ConstrainedExecution;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using System.Windows.Forms;
using System.Windows.Forms.VisualStyles;
using Microsoft.Win32;
using Microsoft.Win32.SafeHandles;
using Ookii.Dialogs.WinForms.Interop;
using Ookii.Dialogs.WinForms.Properties;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: CLSCompliant(true)]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: ComVisible(false)]
[assembly: Guid("16078df2-e2d1-4754-9864-84c288a1e9bd")]
[assembly: TargetFramework(".NETFramework,Version=v4.6.2", FrameworkDisplayName = ".NET Framework 4.6.2")]
[assembly: AssemblyCompany("Ookii Dialogs Contributors")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (c) 2009-2021 Ookii Dialogs Contributors")]
[assembly: AssemblyDescription("Ookii.Dialogs.WinForms is a class library for .NET applications providing several common dialogs. Included are classes for task dialogs, credential dialog, progress dialog, input dialog, folder browser dialog, and more.")]
[assembly: AssemblyFileVersion("4.0.0.0")]
[assembly: AssemblyInformationalVersion("4.0.0+9a29825f2a6a902478225f63197f1e9b558e1da2")]
[assembly: AssemblyProduct("Ookii.Dialogs.WinForms")]
[assembly: AssemblyTitle("Ookii.Dialogs.WinForms")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/ookii-dialogs/ookii-dialogs-winforms.git")]
[assembly: AssemblyVersion("4.0.0.0")]
namespace Ookii.Dialogs.WinForms
{
	public static class AdditionalVisualStyleElements
	{
		public static class TextStyle
		{
			private const string _className = "TEXTSTYLE";

			private static VisualStyleElement _mainInstruction;

			private static VisualStyleElement _bodyText;

			public static VisualStyleElement MainInstruction => _mainInstruction ?? (_mainInstruction = VisualStyleElement.CreateElement("TEXTSTYLE", 1, 0));

			public static VisualStyleElement BodyText => _bodyText ?? (_bodyText = VisualStyleElement.CreateElement("TEXTSTYLE", 4, 0));
		}

		public static class TaskDialog
		{
			private const string _className = "TASKDIALOG";

			private static VisualStyleElement _primaryPanel;

			private static VisualStyleElement _secondaryPanel;

			public static VisualStyleElement PrimaryPanel => _primaryPanel ?? (_primaryPanel = VisualStyleElement.CreateElement("TASKDIALOG", 1, 0));

			public static VisualStyleElement SecondaryPanel => _secondaryPanel ?? (_secondaryPanel = VisualStyleElement.CreateElement("TASKDIALOG", 8, 0));
		}
	}
	public sealed class AnimationResource
	{
		public string ResourceFile { get; private set; }

		public int ResourceId { get; private set; }

		public AnimationResource(string resourceFile, int resourceId)
		{
			if (resourceFile == null)
			{
				throw new ArgumentNullException("resourceFile");
			}
			ResourceFile = resourceFile;
			ResourceId = resourceId;
		}

		public static AnimationResource GetShellAnimation(ShellAnimation animation)
		{
			if (!Enum.IsDefined(typeof(ShellAnimation), animation))
			{
				throw new ArgumentOutOfRangeException("animation");
			}
			return new AnimationResource("shell32.dll", (int)animation);
		}

		internal SafeModuleHandle LoadLibrary()
		{
			SafeModuleHandle safeModuleHandle = NativeMethods.LoadLibraryEx(ResourceFile, IntPtr.Zero, NativeMethods.LoadLibraryExFlags.LoadLibraryAsDatafile);
			if (safeModuleHandle.IsInvalid)
			{
				int lastWin32Error = Marshal.GetLastWin32Error();
				if (lastWin32Error == 2)
				{
					throw new FileNotFoundException(string.Format(CultureInfo.CurrentCulture, Resources.FileNotFoundFormat, ResourceFile));
				}
				throw new Win32Exception(lastWin32Error);
			}
			return safeModuleHandle;
		}
	}
	public enum ButtonType
	{
		Custom = 0,
		Ok = 1,
		Yes = 6,
		No = 7,
		Cancel = 2,
		Retry = 4,
		Close = 8
	}
	internal sealed class ComCtlv6ActivationContext : IDisposable
	{
		private IntPtr _cookie;

		private static NativeMethods.ACTCTX _enableThemingActivationContext;

		private static ActivationContextSafeHandle _activationContext;

		private static bool _contextCreationSucceeded;

		private static readonly object _contextCreationLock = new object();

		public ComCtlv6ActivationContext(bool enable)
		{
			if (enable && NativeMethods.IsWindowsXPOrLater && EnsureActivateContextCreated() && !NativeMethods.ActivateActCtx(_activationContext, out _cookie))
			{
				_cookie = IntPtr.Zero;
			}
		}

		~ComCtlv6ActivationContext()
		{
			Dispose(disposing: false);
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		private void Dispose(bool disposing)
		{
			if (_cookie != IntPtr.Zero && NativeMethods.DeactivateActCtx(0u, _cookie))
			{
				_cookie = IntPtr.Zero;
			}
		}

		private static bool EnsureActivateContextCreated()
		{
			lock (_contextCreationLock)
			{
				if (_contextCreationSucceeded)
				{
					return _contextCreationSucceeded;
				}
				string text;
				using (Stream stream = typeof(ComCtlv6ActivationContext).Assembly.GetManifestResourceStream("Ookii.Dialogs.XPThemes.manifest"))
				{
					if (stream == null)
					{
						throw new InvalidOperationException("Unable to retrieve Ookii.Dialogs.XPThemes.manifest embedded resource");
					}
					text = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
					using FileStream destination = new FileStream(text, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.ReadWrite | FileShare.Delete);
					stream.CopyTo(destination);
				}
				NativeMethods.ACTCTX enableThemingActivationContext = default(NativeMethods.ACTCTX);
				enableThemingActivationContext.cbSize = Marshal.SizeOf(typeof(NativeMethods.ACTCTX));
				enableThemingActivationContext.lpSource = text;
				_enableThemingActivationContext = enableThemingActivationContext;
				_activationContext = NativeMethods.CreateActCtx(ref _enableThemingActivationContext);
				_contextCreationSucceeded = !_activationContext.IsInvalid;
				try
				{
					File.Delete(text);
				}
				catch (Exception)
				{
				}
				return _contextCreationSucceeded;
			}
		}
	}
	[DefaultProperty("MainInstruction")]
	[DefaultEvent("UserNameChanged")]
	[Description("Allows access to credential UI for generic credentials.")]
	public class CredentialDialog : Component
	{
		private string _confirmTarget;

		private NetworkCredential _credentials = new NetworkCredential();

		private bool _isSaveChecked;

		private byte[] _additionalEntropy;

		private string _target;

		private static readonly Dictionary<string, NetworkCredential> _applicationInstanceCredentialCache = new Dictionary<string, NetworkCredential>();

		private string _caption;

		private string _text;

		private string _windowTitle;

		private IContainer components;

		[Category("Behavior")]
		[Description("Indicates whether to use the application instance credential cache.")]
		[DefaultValue(false)]
		public bool UseApplicationInstanceCredentialCache { get; set; }

		[Category("Appearance")]
		[Description("Indicates whether the \"Save password\" checkbox is checked.")]
		[DefaultValue(false)]
		public bool IsSaveChecked
		{
			get
			{
				return _isSaveChecked;
			}
			set
			{
				_confirmTarget = null;
				_isSaveChecked = value;
			}
		}

		[Browsable(false)]
		public string Password
		{
			get
			{
				return _credentials.Password;
			}
			private set
			{
				_confirmTarget = null;
				_credentials.Password = value;
				OnPasswordChanged(EventArgs.Empty);
			}
		}

		[Browsable(false)]
		public byte[] AdditionalEntropy
		{
			get
			{
				return _additionalEntropy;
			}
			set
			{
				_additionalEntropy = value;
			}
		}

		[Browsable(false)]
		public NetworkCredential Credentials => _credentials;

		[Browsable(false)]
		public string UserName
		{
			get
			{
				return _credentials.UserName ?? string.Empty;
			}
			private set
			{
				_confirmTarget = null;
				_credentials.UserName = value;
				OnUserNameChanged(EventArgs.Empty);
			}
		}

		[Category("Behavior")]
		[Description("The target for the credentials, typically the server name prefixed by an application-specific identifier.")]
		[DefaultValue("")]
		public string Target
		{
			get
			{
				return _target ?? string.Empty;
			}
			set
			{
				_target = value;
				_confirmTarget = null;
			}
		}

		[Localizable(true)]
		[Category("Appearance")]
		[Description("The title of the credentials dialog.")]
		[DefaultValue("")]
		public string WindowTitle
		{
			get
			{
				return _windowTitle ?? string.Empty;
			}
			set
			{
				_windowTitle = value;
			}
		}

		[Localizable(true)]
		[Category("Appearance")]
		[Description("A brief message that will be displayed in the dialog box.")]
		[DefaultValue("")]
		public string MainInstruction
		{
			get
			{
				return _caption ?? string.Empty;
			}
			set
			{
				_caption = value;
			}
		}

		[Localizable(true)]
		[Category("Appearance")]
		[Description("Additional text to display in the dialog.")]
		[DefaultValue("")]
		[Editor(typeof(MultilineStringEditor), typeof(UITypeEditor))]
		public string Content
		{
			get
			{
				return _text ?? string.Empty;
			}
			set
			{
				_text = value;
			}
		}

		[Localizable(true)]
		[Category("Appearance")]
		[Description("Indicates how the text of the MainInstruction and Content properties is displayed on Windows XP.")]
		[DefaultValue(DownlevelTextMode.MainInstructionAndContent)]
		public DownlevelTextMode DownlevelTextMode { get; set; }

		[Category("Appearance")]
		[Description("Indicates whether a check box is shown on the dialog that allows the user to choose whether to save the credentials or not.")]
		[DefaultValue(false)]
		public bool ShowSaveCheckBox { get; set; }

		[Category("Behavior")]
		[Description("Indicates whether the dialog should be displayed even when saved credentials exist for the specified target.")]
		[DefaultValue(false)]
		public bool ShowUIForSavedCredentials { get; set; }

		public bool IsStoredCredential { get; private set; }

		[Category("Property Changed")]
		[Description("Event raised when the value of the UserName property changes.")]
		public event EventHandler UserNameChanged;

		[Category("Property Changed")]
		[Description("Event raised when the value of the Password property changes.")]
		public event EventHandler PasswordChanged;

		public CredentialDialog()
		{
			InitializeComponent();
		}

		public CredentialDialog(IContainer container)
		{
			container?.Add(this);
			InitializeComponent();
		}

		[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
		public DialogResult ShowDialog()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return ShowDialog(null);
		}

		[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
		public DialogResult ShowDialog(IntPtr owner)
		{
			if (string.IsNullOrEmpty(_target))
			{
				throw new InvalidOperationException(Resources.CredentialEmptyTargetError);
			}
			UserName = "";
			Password = "";
			IsStoredCredential = false;
			if (RetrieveCredentialsFromApplicationInstanceCache())
			{
				IsStoredCredential = true;
				_confirmTarget = Target;
				return (DialogResult)1;
			}
			bool storedCredentials = false;
			if (ShowSaveCheckBox && RetrieveCredentials())
			{
				IsSaveChecked = true;
				if (!ShowUIForSavedCredentials)
				{
					IsStoredCredential = true;
					_confirmTarget = Target;
					return (DialogResult)1;
				}
				storedCredentials = true;
			}
			IntPtr owner2 = ((owner == IntPtr.Zero) ? NativeMethods.GetActiveWindow() : owner);
			if ((!NativeMethods.IsWindowsVistaOrLater) ? PromptForCredentialsCredUI(owner2, storedCredentials) : PromptForCredentialsCredUIWin(owner2, storedCredentials))
			{
				return (DialogResult)1;
			}
			return (DialogResult)2;
		}

		[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
		public DialogResult ShowDialog(IWin32Window owner)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			IntPtr owner2 = ((owner != null) ? owner.Handle : NativeMethods.GetActiveWindow());
			return ShowDialog(owner2);
		}

		public void ConfirmCredentials(bool confirm)
		{
			if (_confirmTarget == null || _confirmTarget != Target)
			{
				throw new InvalidOperationException(Resources.CredentialPromptNotCalled);
			}
			_confirmTarget = null;
			if (!(IsSaveChecked && confirm))
			{
				return;
			}
			if (UseApplicationInstanceCredentialCache)
			{
				lock (_applicationInstanceCredentialCache)
				{
					_applicationInstanceCredentialCache[Target] = new NetworkCredential(UserName, Password);
				}
			}
			StoreCredential(Target, Credentials, AdditionalEntropy);
		}

		public static void StoreCredential(string target, NetworkCredential credential, byte[] additionalEntropy = null)
		{
			if (target == null)
			{
				throw new ArgumentNullException("target");
			}
			if (target.Length == 0)
			{
				throw new ArgumentException(Resources.CredentialEmptyTargetError, "target");
			}
			if (credential == null)
			{
				throw new ArgumentNullException("credential");
			}
			NativeMethods.CREDENTIAL Credential = default(NativeMethods.CREDENTIAL);
			Credential.UserName = credential.UserName;
			Credential.TargetName = target;
			Credential.Persist = NativeMethods.CredPersist.Enterprise;
			byte[] array = EncryptPassword(credential.Password, additionalEntropy);
			Credential.CredentialBlob = Marshal.AllocHGlobal(array.Length);
			try
			{
				Marshal.Copy(array, 0, Credential.CredentialBlob, array.Length);
				Credential.CredentialBlobSize = (uint)array.Length;
				Credential.Type = NativeMethods.CredTypes.CRED_TYPE_GENERIC;
				if (!NativeMethods.CredWrite(ref Credential, 0))
				{
					throw new CredentialException(Marshal.GetLastWin32Error());
				}
			}
			finally
			{
				Marshal.FreeCoTaskMem(Credential.CredentialBlob);
			}
		}

		public static NetworkCredential RetrieveCredential(string target, byte[] additionalEntropy = null)
		{
			if (target == null)
			{
				throw new ArgumentNullException("target");
			}
			if (target.Length == 0)
			{
				throw new ArgumentException(Resources.CredentialEmptyTargetError, "target");
			}
			NetworkCredential networkCredential = RetrieveCredentialFromApplicationInstanceCache(target);
			if (networkCredential != null)
			{
				return networkCredential;
			}
			IntPtr Credential;
			bool num = NativeMethods.CredRead(target, NativeMethods.CredTypes.CRED_TYPE_GENERIC, 0, out Credential);
			int lastWin32Error = Marshal.GetLastWin32Error();
			if (num)
			{
				try
				{
					NativeMethods.CREDENTIAL obj = (NativeMethods.CREDENTIAL)Marshal.PtrToStructure(Credential, typeof(NativeMethods.CREDENTIAL));
					byte[] array = new byte[obj.CredentialBlobSize];
					Marshal.Copy(obj.CredentialBlob, array, 0, array.Length);
					return new NetworkCredential(obj.UserName, DecryptPassword(array, additionalEntropy));
				}
				finally
				{
					NativeMethods.CredFree(Credential);
				}
			}
			if (lastWin32Error == 1168)
			{
				return null;
			}
			throw new CredentialException(lastWin32Error);
		}

		public static NetworkCredential RetrieveCredentialFromApplicationInstanceCache(string target)
		{
			if (target == null)
			{
				throw new ArgumentNullException("target");
			}
			if (target.Length == 0)
			{
				throw new ArgumentException(Resources.CredentialEmptyTargetError, "target");
			}
			lock (_applicationInstanceCredentialCache)
			{
				if (_applicationInstanceCredentialCache.TryGetValue(target, out var value))
				{
					return value;
				}
			}
			return null;
		}

		public static bool DeleteCredential(string target)
		{
			if (target == null)
			{
				throw new ArgumentNullException("target");
			}
			if (target.Length == 0)
			{
				throw new ArgumentException(Resources.CredentialEmptyTargetError, "target");
			}
			bool result = false;
			lock (_applicationInstanceCredentialCache)
			{
				result = _applicationInstanceCredentialCache.Remove(target);
			}
			if (NativeMethods.CredDelete(target, NativeMethods.CredTypes.CRED_TYPE_GENERIC, 0))
			{
				result = true;
			}
			else
			{
				int lastWin32Error = Marshal.GetLastWin32Error();
				if (lastWin32Error != 1168)
				{
					throw new CredentialException(lastWin32Error);
				}
			}
			return result;
		}

		protected virtual void OnUserNameChanged(EventArgs e)
		{
			if (this.UserNameChanged != null)
			{
				this.UserNameChanged(this, e);
			}
		}

		protected virtual void OnPasswordChanged(EventArgs e)
		{
			if (this.PasswordChanged != null)
			{
				this.PasswordChanged(this, e);
			}
		}

		private bool PromptForCredentialsCredUI(IntPtr owner, bool storedCredentials)
		{
			NativeMethods.CREDUI_INFO pUiInfo = CreateCredUIInfo(owner, downlevelText: true);
			NativeMethods.CREDUI_FLAGS cREDUI_FLAGS = NativeMethods.CREDUI_FLAGS.DO_NOT_PERSIST | NativeMethods.CREDUI_FLAGS.ALWAYS_SHOW_UI | NativeMethods.CREDUI_FLAGS.GENERIC_CREDENTIALS;
			if (ShowSaveCheckBox)
			{
				cREDUI_FLAGS |= NativeMethods.CREDUI_FLAGS.SHOW_SAVE_CHECK_BOX;
			}
			StringBuilder stringBuilder = new StringBuilder(513);
			stringBuilder.Append(UserName);
			StringBuilder stringBuilder2 = new StringBuilder(256);
			stringBuilder2.Append(Password);
			NativeMethods.CredUIReturnCodes credUIReturnCodes = NativeMethods.CredUIPromptForCredentials(ref pUiInfo, Target, IntPtr.Zero, 0, stringBuilder, 513u, stringBuilder2, 256u, ref _isSaveChecked, cREDUI_FLAGS);
			switch (credUIReturnCodes)
			{
			case NativeMethods.CredUIReturnCodes.NO_ERROR:
				UserName = stringBuilder.ToString();
				Password = stringBuilder2.ToString();
				if (ShowSaveCheckBox)
				{
					_confirmTarget = Target;
					if (storedCredentials && !IsSaveChecked)
					{
						DeleteCredential(Target);
					}
				}
				return true;
			case NativeMethods.CredUIReturnCodes.ERROR_CANCELLED:
				return false;
			default:
				throw new CredentialException((int)credUIReturnCodes);
			}
		}

		private bool PromptForCredentialsCredUIWin(IntPtr owner, bool storedCredentials)
		{
			NativeMethods.CREDUI_INFO pUiInfo = CreateCredUIInfo(owner, downlevelText: false);
			NativeMethods.CredUIWinFlags credUIWinFlags = NativeMethods.CredUIWinFlags.Generic;
			if (ShowSaveCheckBox)
			{
				credUIWinFlags |= NativeMethods.CredUIWinFlags.Checkbox;
			}
			IntPtr intPtr = IntPtr.Zero;
			IntPtr ppvOutAuthBuffer = IntPtr.Zero;
			try
			{
				uint pcbPackedCredentials = 0u;
				if (UserName.Length > 0)
				{
					NativeMethods.CredPackAuthenticationBuffer(0u, UserName, Password, IntPtr.Zero, ref pcbPackedCredentials);
					if (pcbPackedCredentials != 0)
					{
						intPtr = Marshal.AllocCoTaskMem((int)pcbPackedCredentials);
						if (!NativeMethods.CredPackAuthenticationBuffer(0u, UserName, Password, intPtr, ref pcbPackedCredentials))
						{
							throw new CredentialException(Marshal.GetLastWin32Error());
						}
					}
				}
				uint pulAuthPackage = 0u;
				uint pulOutAuthBufferSize;
				NativeMethods.CredUIReturnCodes credUIReturnCodes = NativeMethods.CredUIPromptForWindowsCredentials(ref pUiInfo, 0u, ref pulAuthPackage, intPtr, pcbPackedCredentials, out ppvOutAuthBuffer, out pulOutAuthBufferSize, ref _isSaveChecked, credUIWinFlags);
				switch (credUIReturnCodes)
				{
				case NativeMethods.CredUIReturnCodes.NO_ERROR:
				{
					StringBuilder stringBuilder = new StringBuilder(513);
					StringBuilder stringBuilder2 = new StringBuilder(256);
					uint pcchMaxUserName = (uint)stringBuilder.Capacity;
					uint pcchMaxPassword = (uint)stringBuilder2.Capacity;
					uint pcchMaxDomainName = 0u;
					if (!NativeMethods.CredUnPackAuthenticationBuffer(0u, ppvOutAuthBuffer, pulOutAuthBufferSize, stringBuilder, ref pcchMaxUserName, null, ref pcchMaxDomainName, stringBuilder2, ref pcchMaxPassword))
					{
						throw new CredentialException(Marshal.GetLastWin32Error());
					}
					UserName = stringBuilder.ToString();
					Password = stringBuilder2.ToString();
					if (ShowSaveCheckBox)
					{
						_confirmTarget = Target;
						if (storedCredentials && !IsSaveChecked)
						{
							DeleteCredential(Target);
						}
					}
					return true;
				}
				case NativeMethods.CredUIReturnCodes.ERROR_CANCELLED:
					return false;
				default:
					throw new CredentialException((int)credUIReturnCodes);
				}
			}
			finally
			{
				if (intPtr != IntPtr.Zero)
				{
					Marshal.FreeCoTaskMem(intPtr);
				}
				if (ppvOutAuthBuffer != IntPtr.Zero)
				{
					Marshal.FreeCoTaskMem(ppvOutAuthBuffer);
				}
			}
		}

		private NativeMethods.CREDUI_INFO CreateCredUIInfo(IntPtr owner, bool downlevelText)
		{
			NativeMethods.CREDUI_INFO cREDUI_INFO = default(NativeMethods.CREDUI_INFO);
			cREDUI_INFO.cbSize = Marshal.SizeOf(cREDUI_INFO);
			cREDUI_INFO.hwndParent = owner;
			if (downlevelText)
			{
				cREDUI_INFO.pszCaptionText = WindowTitle;
				switch (DownlevelTextMode)
				{
				case DownlevelTextMode.MainInstructionAndContent:
					if (MainInstruction.Length == 0)
					{
						cREDUI_INFO.pszMessageText = Content;
					}
					else if (Content.Length == 0)
					{
						cREDUI_INFO.pszMessageText = MainInstruction;
					}
					else
					{
						cREDUI_INFO.pszMessageText = MainInstruction + Environment.NewLine + Environment.NewLine + Content;
					}
					break;
				case DownlevelTextMode.MainInstructionOnly:
					cREDUI_INFO.pszMessageText = MainInstruction;
					break;
				case DownlevelTextMode.ContentOnly:
					cREDUI_INFO.pszMessageText = Content;
					break;
				}
			}
			else
			{
				cREDUI_INFO.pszMessageText = Content;
				cREDUI_INFO.pszCaptionText = MainInstruction;
			}
			return cREDUI_INFO;
		}

		private bool RetrieveCredentials()
		{
			NetworkCredential networkCredential = RetrieveCredential(Target, AdditionalEntropy);
			if (networkCredential != null)
			{
				UserName = networkCredential.UserName;
				Password = networkCredential.Password;
				return true;
			}
			return false;
		}

		private static byte[] EncryptPassword(string password, byte[] additionalEntropy)
		{
			return ProtectedData.Protect(Encoding.UTF8.GetBytes(password), additionalEntropy, (DataProtectionScope)0);
		}

		private static string DecryptPassword(byte[] encrypted, byte[] additionalEntropy)
		{
			try
			{
				return Encoding.UTF8.GetString(ProtectedData.Unprotect(encrypted, additionalEntropy, (DataProtectionScope)0));
			}
			catch (CryptographicException)
			{
				return string.Empty;
			}
		}

		private bool RetrieveCredentialsFromApplicationInstanceCache()
		{
			if (UseApplicationInstanceCredentialCache)
			{
				NetworkCredential networkCredential = RetrieveCredentialFromApplicationInstanceCache(Target);
				if (networkCredential != null)
				{
					UserName = networkCredential.UserName;
					Password = networkCredential.Password;
					return true;
				}
			}
			return false;
		}

		protected override void Dispose(bool disposing)
		{
			try
			{
				if (disposing && components != null)
				{
					components.Dispose();
				}
			}
			finally
			{
				base.Dispose(disposing);
			}
		}

		private void InitializeComponent()
		{
			components = new Container();
		}
	}
	[Serializable]
	public class CredentialException : Win32Exception
	{
		[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
		public CredentialException()
			: base(Resources.CredentialError)
		{
		}

		[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
		public CredentialException(int error)
			: base(error)
		{
		}

		[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
		public CredentialException(string message)
			: base(message)
		{
		}

		[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
		public CredentialException(int error, string message)
			: base(error, message)
		{
		}

		[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
		public CredentialException(string message, Exception innerException)
			: base(message, innerException)
		{
		}

		[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
		protected CredentialException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	internal static class DialogHelper
	{
		public static bool IsTaskDialogThemeSupported
		{
			get
			{
				if (NativeMethods.IsWindowsVistaOrLater && VisualStyleRenderer.IsSupported)
				{
					return Application.RenderWithVisualStyles;
				}
				return false;
			}
		}

		public static int GetTextHeight(IDeviceContext dc, string mainInstruction, string content, Font mainInstructionFallbackFont, Font contentFallbackFont, int width)
		{
			Point location = Point.Empty;
			DrawText(dc, mainInstruction, content, ref location, mainInstructionFallbackFont, contentFallbackFont, measureOnly: true, width);
			return location.Y;
		}

		public static Size SizeDialog(IDeviceContext dc, string mainInstruction, string content, Screen screen, Font mainInstructionFallbackFont, Font contentFallbackFont, int horizontalSpacing, int verticalSpacing, int minimumWidth, int textMinimumHeight)
		{
			int num = minimumWidth - horizontalSpacing;
			int num2;
			for (num2 = GetTextHeight(dc, mainInstruction, content, mainInstructionFallbackFont, contentFallbackFont, num); num2 > num; num2 = GetTextHeight(dc, mainInstruction, content, mainInstructionFallbackFont, contentFallbackFont, num))
			{
				num = (int)(Math.Sqrt(num2 * num) * 1.1);
			}
			if (num2 < textMinimumHeight)
			{
				num2 = textMinimumHeight;
			}
			int num3 = num + horizontalSpacing;
			int num4 = num2 + verticalSpacing;
			Rectangle workingArea = screen.WorkingArea;
			if ((double)num4 > 0.9 * (double)workingArea.Height)
			{
				int num5 = num2 * num;
				num4 = (int)(0.9 * (double)workingArea.Height);
				num2 = num4 - verticalSpacing;
				num = num5 / num2;
				num3 = num + horizontalSpacing;
			}
			if ((double)num3 > 0.9 * (double)workingArea.Width)
			{
				num3 = (int)(0.9 * (double)workingArea.Width);
			}
			return new Size(num3, num4);
		}

		public static void DrawText(IDeviceContext dc, string text, VisualStyleElement element, Font fallbackFont, ref Point location, bool measureOnly, int width)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			Rectangle rectangle = new Rectangle(location.X, location.Y, width, NativeMethods.IsWindowsXPOrLater ? int.MaxValue : 100000);
			TextFormatFlags val = (TextFormatFlags)16;
			if (IsTaskDialogThemeSupported)
			{
				VisualStyleRenderer val2 = new VisualStyleRenderer(element);
				Rectangle textExtent = val2.GetTextExtent(dc, rectangle, text, val);
				location += new Size(0, textExtent.Height);
				if (!measureOnly)
				{
					val2.DrawText(dc, textExtent, text, false, val);
				}
			}
			else
			{
				if (!measureOnly)
				{
					TextRenderer.DrawText(dc, text, fallbackFont, rectangle, SystemColors.WindowText, val);
				}
				location += new Size(0, TextRenderer.MeasureText(dc, text, fallbackFont, new Size(rectangle.Width, rectangle.Height), val).Height);
			}
		}

		public static void DrawText(IDeviceContext dc, string mainInstruction, string content, ref Point location, Font mainInstructionFallbackFont, Font contentFallbackFont, bool measureOnly, int width)
		{
			if (!string.IsNullOrEmpty(mainInstruction))
			{
				DrawText(dc, mainInstruction, AdditionalVisualStyleElements.TextStyle.MainInstruction, mainInstructionFallbackFont, ref location, measureOnly, width);
			}
			if (!string.IsNullOrEmpty(content))
			{
				if (!string.IsNullOrEmpty(mainInstruction))
				{
					content = Environment.NewLine + content;
				}
				DrawText(dc, content, AdditionalVisualStyleElements.TextStyle.BodyText, contentFallbackFont, ref location, measureOnly, width);
			}
		}
	}
	public enum DownlevelTextMode
	{
		MainInstructionAndContent,
		MainInstructionOnly,
		ContentOnly
	}
	public class ExpandButtonClickedEventArgs : EventArgs
	{
		private bool _expanded;

		public bool Expanded => _expanded;

		public ExpandButtonClickedEventArgs(bool expanded)
		{
			_expanded = expanded;
		}
	}
	public class ExtendedForm : Form
	{
		private bool _useSystemFont;

		private Padding _glassMargin;

		private bool _allowGlassDragging = true;

		[Category("Appearance")]
		[DefaultValue(false)]
		[Description("Indicates whether or not the form automatically uses the system default font.")]
		public bool UseSystemFont
		{
			get
			{
				return _useSystemFont;
			}
			set
			{
				_useSystemFont = value;
			}
		}

		[Category("Appearance")]
		[Description("The glass margins of the form.")]
		public Padding GlassMargin
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return _glassMargin;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				if (_glassMargin != value)
				{
					_glassMargin = value;
					EnableGlass();
				}
			}
		}

		[Category("Behavior")]
		[Description("Indicates whether the form can be dragged by the glass areas inside the client area.")]
		[DefaultValue(true)]
		public bool AllowGlassDragging
		{
			get
			{
				return _allowGlassDragging;
			}
			set
			{
				_allowGlassDragging = value;
			}
		}

		public event EventHandler DwmCompositionChanged;

		protected virtual void OnDwmCompositionChanged(EventArgs e)
		{
			this.DwmCompositionChanged?.Invoke(this, e);
		}

		protected override void OnLoad(EventArgs e)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			if (!((Component)this).DesignMode && _useSystemFont)
			{
				((Control)this).Font = SystemFonts.IconTitleFont;
				SystemEvents.UserPreferenceChanged += new UserPreferenceChangedEventHandler(SystemEvents_UserPreferenceChanged);
			}
			((Form)this).OnLoad(e);
		}

		protected override void OnFormClosed(FormClosedEventArgs e)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			((Form)this).OnFormClosed(e);
			SystemEvents.UserPreferenceChanged -= new UserPreferenceChangedEventHandler(SystemEvents_UserPreferenceChanged);
		}

		protected override void OnPaintBackground(PaintEventArgs pevent)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			if (((Component)this).DesignMode || Glass.IsDwmCompositionEnabled)
			{
				if (((Component)this).DesignMode)
				{
					HatchBrush val = new HatchBrush((HatchStyle)51, Color.SkyBlue, ((Control)this).BackColor);
					try
					{
						PaintGlassArea(pevent, (Brush)(object)val);
						return;
					}
					finally
					{
						((IDisposable)val)?.Dispose();
					}
				}
				PaintGlassArea(pevent, Brushes.Black);
			}
			else
			{
				((ScrollableControl)this).OnPaintBackground(pevent);
			}
		}

		protected override void OnResize(EventArgs e)
		{
			((Form)this).OnResize(e);
			if (((Padding)(ref _glassMargin)).All != 0)
			{
				((Control)this).Invalidate();
			}
		}

		protected override void OnHandleCreated(EventArgs e)
		{
			EnableGlass();
			((Form)this).OnHandleCreated(e);
		}

		[SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
		protected override void WndProc(ref Message m)
		{
			((Form)this).WndProc(ref m);
			switch (((Message)(ref m)).Msg)
			{
			case 132:
			{
				if (!_allowGlassDragging || !(((Message)(ref m)).Result == new IntPtr(1)) || !Glass.IsDwmCompositionEnabled)
				{
					break;
				}
				if (((Padding)(ref _glassMargin)).Left == -1 && ((Padding)(ref _glassMargin)).Top == -1 && ((Padding)(ref _glassMargin)).Right == -1 && ((Padding)(ref _glassMargin)).Bottom == -1)
				{
					((Message)(ref m)).Result = new IntPtr(2);
					break;
				}
				Point point = new Point((int)((Message)(ref m)).LParam & 0xFFFF, (int)((Message)(ref m)).LParam >> 16);
				point = ((Control)this).PointToClient(point);
				if (point.X < ((Padding)(ref _glassMargin)).Left || point.X > ((Form)this).ClientSize.Width - ((Padding)(ref _glassMargin)).Right || point.Y < ((Padding)(ref _glassMargin)).Top || point.Y > ((Form)this).ClientSize.Height - ((Padding)(ref _glassMargin)).Bottom)
				{
					((Message)(ref m)).Result = new IntPtr(2);
				}
				break;
			}
			case 798:
				if (((Padding)(ref _glassMargin)).All != 0)
				{
					EnableGlass();
				}
				OnDwmCompositionChanged(EventArgs.Empty);
				((Message)(ref m)).Result = IntPtr.Zero;
				break;
			}
		}

		protected override void ScaleControl(SizeF factor, BoundsSpecified specified)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			float width = factor.Width;
			Padding glassMargin = GlassMargin;
			if (width != 1f)
			{
				if (((Padding)(ref glassMargin)).Left > 0)
				{
					((Padding)(ref glassMargin)).Left = (int)Math.Round((float)((Padding)(ref glassMargin)).Left * width);
				}
				if (((Padding)(ref glassMargin)).Right > 0)
				{
					((Padding)(ref glassMargin)).Right = (int)Math.Round((float)((Padding)(ref glassMargin)).Right * width);
				}
			}
			float height = factor.Height;
			if (height != 1f)
			{
				if (((Padding)(ref glassMargin)).Top > 0)
				{
					((Padding)(ref glassMargin)).Top = (int)Math.Round((float)((Padding)(ref glassMargin)).Top * height);
				}
				if (((Padding)(ref glassMargin)).Bottom > 0)
				{
					((Padding)(ref glassMargin)).Bottom = (int)Math.Round((float)((Padding)(ref glassMargin)).Bottom * height);
				}
			}
			GlassMargin = glassMargin;
			((Form)this).ScaleControl(factor, specified);
		}

		private void EnableGlass()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (!((Component)this).DesignMode && Glass.IsDwmCompositionEnabled)
			{
				((IWin32Window)(object)this).ExtendFrameIntoClientArea(GlassMargin);
				((Control)this).Invalidate();
			}
		}

		private void PaintGlassArea(PaintEventArgs pevent, Brush brush)
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			if (((Padding)(ref _glassMargin)).Left == -1 && ((Padding)(ref _glassMargin)).Top == -1 && ((Padding)(ref _glassMargin)).Right == -1 && ((Padding)(ref _glassMargin)).Bottom == -1)
			{
				pevent.Graphics.FillRectangle(brush, pevent.ClipRectangle);
				return;
			}
			Rectangle rectangle = new Rectangle(((Padding)(ref _glassMargin)).Left, ((Padding)(ref _glassMargin)).Top, ((Form)this).ClientSize.Width - ((Padding)(ref _glassMargin)).Right, ((Form)this).ClientSize.Height - ((Padding)(ref _glassMargin)).Bottom);
			pevent.Graphics.FillRectangle((Brush)new SolidBrush(((Control)this).BackColor), rectangle);
			if (((Padding)(ref _glassMargin)).Left != 0)
			{
				pevent.Graphics.FillRectangle(brush, new Rectangle(0, 0, ((Padding)(ref _glassMargin)).Left, ((Form)this).ClientSize.Height));
			}
			if (((Padding)(ref _glassMargin)).Right != 0)
			{
				pevent.Graphics.FillRectangle(brush, new Rectangle(((Form)this).ClientSize.Width - ((Padding)(ref _glassMargin)).Right, 0, ((Form)this).ClientSize.Width, ((Form)this).ClientSize.Height));
			}
			if (((Padding)(ref _glassMargin)).Top != 0)
			{
				pevent.Graphics.FillRectangle(brush, new Rectangle(0, 0, ((Form)this).ClientSize.Width, ((Padding)(ref _glassMargin)).Top));
			}
			if (((Padding)(ref _glassMargin)).Bottom != 0)
			{
				pevent.Graphics.FillRectangle(brush, new Rectangle(0, ((Form)this).ClientSize.Height - ((Padding)(ref _glassMargin)).Bottom, ((Form)this).ClientSize.Width, ((Form)this).ClientSize.Height));
			}
		}

		private void SystemEvents_UserPreferenceChanged(object sender, UserPreferenceChangedEventArgs e)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			if ((int)e.Category == 12 && _useSystemFont)
			{
				((Control)this).Font = SystemFonts.IconTitleFont;
			}
		}
	}
	public static class Glass
	{
		public static bool OSSupportsDwmComposition => NativeMethods.IsWindowsVistaOrLater;

		public static bool IsDwmCompositionEnabled
		{
			get
			{
				if (OSSupportsDwmComposition)
				{
					return NativeMethods.DwmIsCompositionEnabled();
				}
				return false;
			}
		}

		public static void ExtendFrameIntoClientArea(this IWin32Window window, Padding glassMargin)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			if (!IsDwmCompositionEnabled)
			{
				throw new NotSupportedException(Resources.GlassNotSupportedError);
			}
			if (window == null)
			{
				throw new ArgumentNullException("window");
			}
			NativeMethods.MARGINS pMarInset = new NativeMethods.MARGINS(glassMargin);
			NativeMethods.DwmExtendFrameIntoClientArea(window.Handle, ref pMarInset);
		}

		public static void DrawCompositedText(IDeviceContext dc, string text, Font font, Rectangle bounds, Padding padding, Color foreColor, int glowSize, TextFormatFlags textFormat)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected I4, but got Unknown
			if (!IsDwmCompositionEnabled)
			{
				throw new NotSupportedException(Resources.GlassNotSupportedError);
			}
			if (dc == null)
			{
				throw new ArgumentNullException("dc");
			}
			if (text == null)
			{
				throw new ArgumentNullException("text");
			}
			if (font == null)
			{
				throw new ArgumentNullException("font");
			}
			IntPtr hdc = dc.GetHdc();
			try
			{
				using SafeDeviceHandle safeDeviceHandle = NativeMethods.CreateCompatibleDC(hdc);
				using SafeGDIHandle hObject = new SafeGDIHandle(font.ToHfont(), ownsHandle: true);
				using (NativeMethods.CreateDib(bounds, hdc, safeDeviceHandle))
				{
					NativeMethods.SelectObject(safeDeviceHandle, hObject);
					VisualStyleRenderer val = new VisualStyleRenderer(Caption.Active);
					NativeMethods.DTTOPTS pOptions = new NativeMethods.DTTOPTS
					{
						dwSize = Marshal.SizeOf(typeof(NativeMethods.DTTOPTS)),
						dwFlags = (NativeMethods.DrawThemeTextFlags.TextColor | NativeMethods.DrawThemeTextFlags.GlowSize | NativeMethods.DrawThemeTextFlags.Composited),
						crText = ColorTranslator.ToWin32(foreColor),
						iGlowSize = glowSize
					};
					NativeMethods.RECT pRect = new NativeMethods.RECT(((Padding)(ref padding)).Left, ((Padding)(ref padding)).Top, bounds.Width - ((Padding)(ref padding)).Right, bounds.Height - ((Padding)(ref padding)).Bottom);
					NativeMethods.DrawThemeTextEx(val.Handle, safeDeviceHandle, 0, 0, text, text.Length, (int)textFormat, ref pRect, ref pOptions);
					NativeMethods.BitBlt(hdc, bounds.Left, bounds.Top, bounds.Width, bounds.Height, safeDeviceHandle, 0, 0, 13369376u);
				}
			}
			finally
			{
				dc.ReleaseHdc();
			}
		}

		public static Size MeasureCompositedText(IDeviceContext dc, string text, Font font, TextFormatFlags textFormat)
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected I4, but got Unknown
			if (!IsDwmCompositionEnabled)
			{
				throw new NotSupportedException(Resources.GlassNotSupportedError);
			}
			if (dc == null)
			{
				throw new ArgumentNullException("dc");
			}
			if (text == null)
			{
				throw new ArgumentNullException("text");
			}
			if (font == null)
			{
				throw new ArgumentNullException("font");
			}
			IntPtr hdc = dc.GetHdc();
			try
			{
				Rectangle rectangle = new Rectangle(0, 0, int.MaxValue, int.MaxValue);
				using SafeDeviceHandle safeDeviceHandle = NativeMethods.CreateCompatibleDC(hdc);
				using SafeGDIHandle hObject = new SafeGDIHandle(font.ToHfont(), ownsHandle: true);
				using (NativeMethods.CreateDib(rectangle, hdc, safeDeviceHandle))
				{
					NativeMethods.SelectObject(safeDeviceHandle, hObject);
					VisualStyleRenderer val = new VisualStyleRenderer(Caption.Active);
					NativeMethods.RECT bounds = new NativeMethods.RECT(rectangle);
					NativeMethods.GetThemeTextExtent(val.Handle, safeDeviceHandle, 0, 0, text, text.Length, (int)textFormat, ref bounds, out var rect);
					return new Size(rect.Right - rect.Left, rect.Bottom - rect.Top);
				}
			}
			finally
			{
				dc.ReleaseHdc();
			}
		}
	}
	public class HyperlinkClickedEventArgs : EventArgs
	{
		private string _href;

		public string Href => _href;

		public HyperlinkClickedEventArgs(string href)
		{
			_href = href;
		}
	}
	[DefaultProperty("MainInstruction")]
	[DefaultEvent("ButtonClicked")]
	[Description("A dialog that allows the user to input a single text value.")]
	public class InputDialog : Component, IBindableComponent, IComponent, IDisposable
	{
		private string _mainInstruction;

		private string _content;

		private string _windowTitle;

		private string _input;

		private int _maxLength = 32767;

		private bool _usePasswordMasking;

		private bool _multiLine;

		private BindingContext _context;

		private ControlBindingsCollection _bindings;

		private IContainer components;

		[Localizable(true)]
		[Category("Appearance")]
		[Description("The dialog's main instruction.")]
		[DefaultValue("")]
		[Editor(typeof(MultilineStringEditor), typeof(UITypeEditor))]
		public string MainInstruction
		{
			get
			{
				return _mainInstruction ?? string.Empty;
			}
			set
			{
				_mainInstruction = (string.IsNullOrEmpty(value) ? null : value);
			}
		}

		[Localizable(true)]
		[Category("Appearance")]
		[Description("The dialog's primary content.")]
		[DefaultValue("")]
		[Editor(typeof(MultilineStringEditor), typeof(UITypeEditor))]
		public string Content
		{
			get
			{
				return _content ?? string.Empty;
			}
			set
			{
				_content = (string.IsNullOrEmpty(value) ? null : value);
			}
		}

		[Localizable(true)]
		[Category("Appearance")]
		[Description("The window title of the task dialog.")]
		[DefaultValue("")]
		public string WindowTitle
		{
			get
			{
				return _windowTitle ?? string.Empty;
			}
			set
			{
				_windowTitle = (string.IsNullOrEmpty(value) ? null : value);
			}
		}

		[Localizable(true)]
		[Category("Appearance")]
		[Description("The text specified by the user.")]
		[DefaultValue("")]
		public string Input
		{
			get
			{
				return _input ?? string.Empty;
			}
			set
			{
				_input = (value = (string.IsNullOrEmpty(value) ? null : value));
				OnInputChanged(EventArgs.Empty);
			}
		}

		[Localizable(true)]
		[Category("Behavior")]
		[Description("The maximum number of characters that can be entered into the input field of the dialog.")]
		[DefaultValue(32767)]
		public int MaxLength
		{
			get
			{
				return _maxLength;
			}
			set
			{
				_maxLength = value;
			}
		}

		[Category("Behavior")]
		[Description("Indicates whether the input will be masked using the system password character.")]
		[DefaultValue(false)]
		public bool UsePasswordMasking
		{
			get
			{
				return _usePasswordMasking;
			}
			set
			{
				_usePasswordMasking = value;
			}
		}

		[Category("Behavior")]
		[Description("Indicates whether the input field will have multiline support.")]
		[DefaultValue(false)]
		public bool Multiline
		{
			get
			{
				return _multiLine;
			}
			set
			{
				_multiLine = value;
			}
		}

		[Browsable(false)]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		[EditorBrowsable(EditorBrowsableState.Advanced)]
		public BindingContext BindingContext
		{
			get
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Expected O, but got Unknown
				//IL_0017: Expected O, but got Unknown
				BindingContext obj = _context;
				if (obj == null)
				{
					BindingContext val = new BindingContext();
					BindingContext val2 = val;
					_context = val;
					obj = val2;
				}
				return obj;
			}
			set
			{
				_context = value;
			}
		}

		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[Category("Data")]
		[RefreshProperties(RefreshProperties.All)]
		[ParenthesizePropertyName(true)]
		public ControlBindingsCollection DataBindings
		{
			get
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Expected O, but got Unknown
				//IL_0018: Expected O, but got Unknown
				ControlBindingsCollection obj = _bindings;
				if (obj == null)
				{
					ControlBindingsCollection val = new ControlBindingsCollection((IBindableComponent)(object)this);
					ControlBindingsCollection val2 = val;
					_bindings = val;
					obj = val2;
				}
				return obj;
			}
		}

		[Category("Property Changed")]
		[Description("Event raised when the value of the Input property changes.")]
		public event EventHandler InputChanged;

		[Category("Action")]
		[Description("Event raised when the user clicks the OK button on the dialog.")]
		public event EventHandler<OkButtonClickedEventArgs> OkButtonClicked;

		public InputDialog()
		{
			InitializeComponent();
		}

		public InputDialog(IContainer container)
		{
			container?.Add(this);
			InitializeComponent();
		}

		protected virtual void OnInputChanged(EventArgs e)
		{
			if (this.InputChanged != null)
			{
				this.InputChanged(this, e);
			}
		}

		protected virtual void OnOkButtonClicked(OkButtonClickedEventArgs e)
		{
			if (this.OkButtonClicked != null)
			{
				this.OkButtonClicked(this, e);
			}
		}

		public DialogResult ShowDialog()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return ShowDialog(null);
		}

		public DialogResult ShowDialog(IWin32Window owner)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Invalid comparison between Unknown and I4
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			InputDialogForm inputDialogForm = new InputDialogForm();
			try
			{
				inputDialogForm.MainInstruction = MainInstruction;
				inputDialogForm.Content = Content;
				((Control)inputDialogForm).Text = WindowTitle;
				inputDialogForm.Input = Input;
				inputDialogForm.UsePasswordMasking = UsePasswordMasking;
				inputDialogForm.MaxLength = MaxLength;
				inputDialogForm.Multiline = Multiline;
				inputDialogForm.OkButtonClicked += InputBoxForm_OkButtonClicked;
				DialogResult val = ((Form)inputDialogForm).ShowDialog(owner);
				if ((int)val == 1)
				{
					Input = inputDialogForm.Input;
				}
				return val;
			}
			finally
			{
				((IDisposable)inputDialogForm)?.Dispose();
			}
		}

		private void InputBoxForm_OkButtonClicked(object sender, OkButtonClickedEventArgs e)
		{
			OnOkButtonClicked(e);
		}

		protected override void Dispose(bool disposing)
		{
			try
			{
				if (disposing && components != null)
				{
					components.Dispose();
				}
			}
			finally
			{
				base.Dispose(disposing);
			}
		}

		private void InitializeComponent()
		{
			components = new Container();
		}
	}
	internal class InputDialogForm : ExtendedForm
	{
		private SizeF _textMargin = new SizeF(12f, 9f);

		private string _mainInstruction;

		private string _content;

		private IContainer components;

		private Panel _primaryPanel;

		private Panel _secondaryPanel;

		private Button _cancelButton;

		private Button _okButton;

		private TextBox _inputTextBox;

		public string MainInstruction
		{
			get
			{
				return _mainInstruction;
			}
			set
			{
				_mainInstruction = value;
			}
		}

		public string Content
		{
			get
			{
				return _content;
			}
			set
			{
				_content = value;
			}
		}

		public string Input
		{
			get
			{
				return ((Control)_inputTextBox).Text;
			}
			set
			{
				((Control)_inputTextBox).Text = value;
			}
		}

		public int MaxLength
		{
			get
			{
				return ((TextBoxBase)_inputTextBox).MaxLength;
			}
			set
			{
				((TextBoxBase)_inputTextBox).MaxLength = value;
			}
		}

		public bool UsePasswordMasking
		{
			get
			{
				return _inputTextBox.UseSystemPasswordChar;
			}
			set
			{
				_inputTextBox.UseSystemPasswordChar = value;
			}
		}

		public bool Multiline
		{
			get
			{
				return ((TextBoxBase)_inputTextBox).Multiline;
			}
			set
			{
				if (value != ((TextBoxBase)_inputTextBox).Multiline)
				{
					((TextBoxBase)_inputTextBox).Multiline = value;
					if (value)
					{
						((Form)this).AcceptButton = null;
						int num = ((Control)_inputTextBox).Height * 2;
						TextBox inputTextBox = _inputTextBox;
						((Control)inputTextBox).Top = ((Control)inputTextBox).Top - num;
						TextBox inputTextBox2 = _inputTextBox;
						((Control)inputTextBox2).Height = ((Control)inputTextBox2).Height + num;
						((Control)this).Height = ((Control)this).Height + num;
					}
					else
					{
						((Form)this).AcceptButton = (IButtonControl)(object)_okButton;
						int num = ((Control)_inputTextBox).Height / 3 * 2;
						((Control)this).Height = ((Control)this).Height - num;
						TextBox inputTextBox3 = _inputTextBox;
						((Control)inputTextBox3).Top = ((Control)inputTextBox3).Top + num;
						TextBox inputTextBox4 = _inputTextBox;
						((Control)inputTextBox4).Height = ((Control)inputTextBox4).Height - num;
					}
				}
			}
		}

		public event EventHandler<OkButtonClickedEventArgs> OkButtonClicked;

		public InputDialogForm()
		{
			InitializeComponent();
		}

		public DialogResult ShowDialog(IntPtr owner)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			IntPtr intPtr = ((owner == (IntPtr)0) ? NativeMethods.GetActiveWindow() : owner);
			NativeWindow val = new NativeWindow();
			val.AssignHandle(intPtr);
			try
			{
				return ((Form)this).ShowDialog((IWin32Window)(object)val);
			}
			finally
			{
				val.ReleaseHandle();
			}
		}

		protected virtual void OnOkButtonClicked(OkButtonClickedEventArgs e)
		{
			if (this.OkButtonClicked != null)
			{
				this.OkButtonClicked(this, e);
			}
		}

		protected override void ScaleControl(SizeF factor, BoundsSpecified specified)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			_textMargin = new SizeF(_textMargin.Width * factor.Width, _textMargin.Height * factor.Height);
			base.ScaleControl(factor, specified);
		}

		private void SizeDialog()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected O, but got Unknown
			int horizontalSpacing = (int)_textMargin.Width * 2;
			int verticalSpacing = ((Form)this).ClientSize.Height - ((Control)_inputTextBox).Top + (int)_textMargin.Height * 3;
			Graphics val = ((Control)_primaryPanel).CreateGraphics();
			try
			{
				((Form)this).ClientSize = DialogHelper.SizeDialog((IDeviceContext)(object)val, MainInstruction, Content, Screen.FromControl((Control)(object)this), new Font(((Control)this).Font, (FontStyle)1), ((Control)this).Font, horizontalSpacing, verticalSpacing, ((Form)this).ClientSize.Width, 0);
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}

		private static void DrawThemeBackground(IDeviceContext dc, VisualStyleElement element, Rectangle bounds, Rectangle clipRectangle)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (DialogHelper.IsTaskDialogThemeSupported)
			{
				new VisualStyleRenderer(element).DrawBackground(dc, bounds, clipRectangle);
			}
		}

		private void DrawText(IDeviceContext dc, ref Point location, bool measureOnly, int width)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			DialogHelper.DrawText(dc, MainInstruction, Content, ref location, new Font(((Control)this).Font, (FontStyle)1), ((Control)this).Font, measureOnly, width);
		}

		private void _primaryPanel_Paint(object sender, PaintEventArgs e)
		{
			DrawThemeBackground((IDeviceContext)(object)e.Graphics, AdditionalVisualStyleElements.TaskDialog.PrimaryPanel, ((Control)_primaryPanel).ClientRectangle, e.ClipRectangle);
			Point location = new Point((int)_textMargin.Width, (int)_textMargin.Height);
			DrawText((IDeviceContext)(object)e.Graphics, ref location, measureOnly: false, ((Form)this).ClientSize.Width - (int)_textMargin.Width * 2);
		}

		private void _secondaryPanel_Paint(object sender, PaintEventArgs e)
		{
			DrawThemeBackground((IDeviceContext)(object)e.Graphics, AdditionalVisualStyleElements.TaskDialog.SecondaryPanel, ((Control)_secondaryPanel).ClientRectangle, e.ClipRectangle);
		}

		private void NewInputBoxForm_Load(object sender, EventArgs e)
		{
			SizeDialog();
			((Form)this).CenterToScreen();
		}

		private void _okButton_Click(object sender, EventArgs e)
		{
			OkButtonClickedEventArgs okButtonClickedEventArgs = new OkButtonClickedEventArgs(((Control)_inputTextBox).Text, (IWin32Window)(object)this);
			OnOkButtonClicked(okButtonClickedEventArgs);
			if (!okButtonClickedEventArgs.Cancel)
			{
				((Form)this).DialogResult = (DialogResult)1;
			}
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing && components != null)
			{
				components.Dispose();
			}
			((Form)this).Dispose(disposing);
		}

		private void InitializeComponent()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			ComponentResourceManager componentResourceManager = new ComponentResourceManager(typeof(InputDialogForm));
			_primaryPanel = new Panel();
			_inputTextBox = new TextBox();
			_secondaryPanel = new Panel();
			_cancelButton = new Button();
			_okButton = new Button();
			((Control)_primaryPanel).SuspendLayout();
			((Control)_secondaryPanel).SuspendLayout();
			((Control)this).SuspendLayout();
			((Control)_primaryPanel).Controls.Add((Control)(object)_inputTextBox);
			componentResourceManager.ApplyResources(_primaryPanel, "_primaryPanel");
			((Control)_primaryPanel).Name = "_primaryPanel";
			((Control)_primaryPanel).Paint += new PaintEventHandler(_primaryPanel_Paint);
			componentResourceManager.ApplyResources(_inputTextBox, "_inputTextBox");
			((Control)_inputTextBox).Name = "_inputTextBox";
			((Control)_secondaryPanel).Controls.Add((Control)(object)_cancelButton);
			((Control)_secondaryPanel).Controls.Add((Control)(object)_okButton);
			componentResourceManager.ApplyResources(_secondaryPanel, "_secondaryPanel");
			((Control)_secondaryPanel).Name = "_secondaryPanel";
			((Control)_secondaryPanel).Paint += new PaintEventHandler(_secondaryPanel_Paint);
			componentResourceManager.ApplyResources(_cancelButton, "_cancelButton");
			_cancelButton.DialogResult = (DialogResult)2;
			((Control)_cancelButton).Name = "_cancelButton";
			((ButtonBase)_cancelButton).UseVisualStyleBackColor = true;
			componentResourceManager.ApplyResources(_okButton, "_okButton");
			((Control)_okButton).Name = "_okButton";
			((ButtonBase)_okButton).UseVisualStyleBackColor = true;
			((Control)_okButton).Click += _okButton_Click;
			((Form)this).AcceptButton = (IButtonControl)(object)_okButton;
			componentResourceManager.ApplyResources(this, "$this");
			((ContainerControl)this).AutoScaleMode = (AutoScaleMode)1;
			((Form)this).CancelButton = (IButtonControl)(object)_cancelButton;
			((Control)this).Controls.Add((Control)(object)_primaryPanel);
			((Control)this).Controls.Add((Control)(object)_secondaryPanel);
			((Form)this).FormBorderStyle = (FormBorderStyle)3;
			((Form)this).MaximizeBox = false;
			((Form)this).MinimizeBox = false;
			((Control)this).Name = "InputDialogForm";
			((Form)this).ShowInTaskbar = false;
			base.UseSystemFont = true;
			((Form)this).Load += NewInputBoxForm_Load;
			((Control)_primaryPanel).ResumeLayout(false);
			((Control)_primaryPanel).PerformLayout();
			((Control)_secondaryPanel).ResumeLayout(false);
			((Control)this).ResumeLayout(false);
		}
	}
	internal static class NativeMethods
	{
		[Flags]
		public enum LoadLibraryExFlags : uint
		{
			DontResolveDllReferences = 1u,
			LoadLibraryAsDatafile = 2u,
			LoadWithAlteredSearchPath = 8u,
			LoadIgnoreCodeAuthzLevel = 0x10u
		}

		public delegate uint TaskDialogCallback(IntPtr hwnd, uint uNotification, IntPtr wParam, IntPtr lParam, IntPtr dwRefData);

		public enum TaskDialogNotifications
		{
			Created,
			Navigated,
			ButtonClicked,
			HyperlinkClicked,
			Timer,
			Destroyed,
			RadioButtonClicked,
			DialogConstructed,
			VerificationClicked,
			Help,
			ExpandoButtonClicked
		}

		[Flags]
		public enum TaskDialogCommonButtonFlags
		{
			OkButton = 1,
			YesButton = 2,
			NoButton = 4,
			CancelButton = 8,
			RetryButton = 0x10,
			CloseButton = 0x20
		}

		[Flags]
		public enum TaskDialogFlags
		{
			EnableHyperLinks = 1,
			UseHIconMain = 2,
			UseHIconFooter = 4,
			AllowDialogCancellation = 8,
			UseCommandLinks = 0x10,
			UseCommandLinksNoIcon = 0x20,
			ExpandFooterArea = 0x40,
			ExpandedByDefault = 0x80,
			VerificationFlagChecked = 0x100,
			ShowProgressBar = 0x200,
			ShowMarqueeProgressBar = 0x400,
			CallbackTimer = 0x800,
			PositionRelativeToWindow = 0x1000,
			RtlLayout = 0x2000,
			NoDefaultRadioButton = 0x4000,
			CanBeMinimized = 0x8000
		}

		public enum TaskDialogMessages
		{
			NavigatePage = 1125,
			ClickButton = 1126,
			SetMarqueeProgressBar = 1127,
			SetProgressBarState = 1128,
			SetProgressBarRange = 1129,
			SetProgressBarPos = 1130,
			SetProgressBarMarquee = 1131,
			SetElementText = 1132,
			ClickRadioButton = 1134,
			EnableButton = 1135,
			EnableRadioButton = 1136,
			ClickVerification = 1137,
			UpdateElementText = 1138,
			SetButtonElevationRequiredState = 1139,
			UpdateIcon = 1140
		}

		public enum TaskDialogElements
		{
			Content,
			ExpandedInformation,
			Footer,
			MainInstruction
		}

		[StructLayout(LayoutKind.Sequential, Pack = 4)]
		public struct TASKDIALOG_BUTTON
		{
			public int nButtonID;

			[MarshalAs(UnmanagedType.LPWStr)]
			public string pszButtonText;
		}

		[StructLayout(LayoutKind.Sequential, Pack = 4)]
		public struct TASKDIALOGCONFIG
		{
			public uint cbSize;

			public IntPtr hwndParent;

			public IntPtr hInstance;

			public TaskDialogFlags dwFlags;

			public TaskDialogCommonButtonFlags dwCommonButtons;

			[MarshalAs(UnmanagedType.LPWStr)]
			public string pszWindowTitle;

			public IntPtr hMainIcon;

			[MarshalAs(UnmanagedType.LPWStr)]
			public string pszMainInstruction;

			[MarshalAs(UnmanagedType.LPWStr)]
			public string pszContent;

			public uint cButtons;

			public IntPtr pButtons;

			public int nDefaultButton;

			public uint cRadioButtons;

			public IntPtr pRadioButtons;

			public int nDefaultRadioButton;

			[MarshalAs(UnmanagedType.LPWStr)]
			public string pszVerificationText;

			[MarshalAs(UnmanagedType.LPWStr)]
			public string pszExpandedInformation;

			[MarshalAs(UnmanagedType.LPWStr)]
			public string pszExpandedControlText;

			[MarshalAs(UnmanagedType.LPWStr)]
			public string pszCollapsedControlText;

			public IntPtr hFooterIcon;

			[MarshalAs(UnmanagedType.LPWStr)]
			public string pszFooterText;

			[MarshalAs(UnmanagedType.FunctionPtr)]
			public TaskDialogCallback pfCallback;

			public IntPtr lpCallbackData;

			public uint cxWidth;
		}

		public struct ACTCTX
		{
			public int cbSize;

			public uint dwFlags;

			public string lpSource;

			public ushort wProcessorArchitecture;

			public ushort wLangId;

			public string lpAssemblyDirectory;

			public string lpResourceName;

			public string lpApplicationName;
		}

		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto, Pack = 4)]
		internal struct COMDLG_FILTERSPEC
		{
			[MarshalAs(UnmanagedType.LPWStr)]
			internal string pszName;

			[MarshalAs(UnmanagedType.LPWStr)]
			internal string pszSpec;
		}

		internal enum FDAP
		{
			FDAP_BOTTOM,
			FDAP_TOP
		}

		internal enum FDE_SHAREVIOLATION_RESPONSE
		{
			FDESVR_DEFAULT,
			FDESVR_ACCEPT,
			FDESVR_REFUSE
		}

		internal enum FDE_OVERWRITE_RESPONSE
		{
			FDEOR_DEFAULT,
			FDEOR_ACCEPT,
			FDEOR_REFUSE
		}

		internal enum SIATTRIBFLAGS
		{
			SIATTRIBFLAGS_AND = 1,
			SIATTRIBFLAGS_OR,
			SIATTRIBFLAGS_APPCOMPAT
		}

		internal enum SIGDN : uint
		{
			SIGDN_NORMALDISPLAY = 0u,
			SIGDN_PARENTRELATIVEPARSING = 2147581953u,
			SIGDN_DESKTOPABSOLUTEPARSING = 2147647488u,
			SIGDN_PARENTRELATIVEEDITING = 2147684353u,
			SIGDN_DESKTOPABSOLUTEEDITING = 2147794944u,
			SIGDN_FILESYSPATH = 2147844096u,
			SIGDN_URL = 2147909632u,
			SIGDN_PARENTRELATIVEFORADDRESSBAR = 2147991553u,
			SIGDN_PARENTRELATIVE = 2148007937u
		}

		[Flags]
		internal enum FOS : uint
		{
			FOS_OVERWRITEPROMPT = 2u,
			FOS_STRICTFILETYPES = 4u,
			FOS_NOCHANGEDIR = 8u,
			FOS_PICKFOLDERS = 0x20u,
			FOS_FORCEFILESYSTEM = 0x40u,
			FOS_ALLNONSTORAGEITEMS = 0x80u,
			FOS_NOVALIDATE = 0x100u,
			FOS_ALLOWMULTISELECT = 0x200u,
			FOS_PATHMUSTEXIST = 0x800u,
			FOS_FILEMUSTEXIST = 0x1000u,
			FOS_CREATEPROMPT = 0x2000u,
			FOS_SHAREAWARE = 0x4000u,
			FOS_NOREADONLYRETURN = 0x8000u,
			FOS_NOTESTFILECREATE = 0x10000u,
			FOS_HIDEMRUPLACES = 0x20000u,
			FOS_HIDEPINNEDPLACES = 0x40000u,
			FOS_NODEREFERENCELINKS = 0x100000u,
			FOS_DONTADDTORECENT = 0x2000000u,
			FOS_FORCESHOWHIDDEN = 0x10000000u,
			FOS_DEFAULTNOMINIMODE = 0x20000000u
		}

		internal enum CDCONTROLSTATE
		{
			CDCS_INACTIVE,
			CDCS_ENABLED,
			CDCS_VISIBLE
		}

		internal enum FFFP_MODE
		{
			FFFP_EXACTMATCH,
			FFFP_NEARESTPARENTMATCH
		}

		[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto, Pack = 4)]
		internal struct KNOWNFOLDER_DEFINITION
		{
			internal KF_CATEGORY category;

			[MarshalAs(UnmanagedType.LPWStr)]
			internal string pszName;

			[MarshalAs(UnmanagedType.LPWStr)]
			internal string pszCreator;

			[MarshalAs(UnmanagedType.LPWStr)]
			internal string pszDescription;

			internal Guid fidParent;

			[MarshalAs(UnmanagedType.LPWStr)]
			internal string pszRelativePath;

			[MarshalAs(UnmanagedType.LPWStr)]
			internal string pszParsingName;

			[MarshalAs(UnmanagedType.LPWStr)]
			internal string pszToolTip;

			[MarshalAs(UnmanagedType.LPWStr)]
			internal string pszLocalizedName;

			[MarshalAs(UnmanagedType.LPWStr)]
			internal string pszIcon;

			[MarshalAs(UnmanagedType.LPWStr)]
			internal string pszSecurity;

			internal uint dwAttributes;

			internal KF_DEFINITION_FLAGS kfdFlags;

			internal Guid ftidType;
		}

		internal enum KF_CATEGORY
		{
			KF_CATEGORY_VIRTUAL = 1,
			KF_CATEGORY_FIXED,
			KF_CATEGORY_COMMON,
			KF_CATEGORY_PERUSER
		}

		[Flags]
		internal enum KF_DEFINITION_FLAGS
		{
			KFDF_PERSONALIZE = 1,
			KFDF_LOCAL_REDIRECT_ONLY = 2,
			KFDF_ROAMABLE = 4
		}

		[StructLayout(LayoutKind.Sequential, Pack = 4)]
		internal struct PROPERTYKEY
		{
			internal Guid fmtid;

			internal uint pid;
		}

		[Flags]
		public enum FormatMessageFlags
		{
			FORMAT_MESSAGE_ALLOCATE_BUFFER = 0x100,
			FORMAT_MESSAGE_IGNORE_INSERTS = 0x200,
			FORMAT_MESSAGE_FROM_STRING = 0x400,
			FORMAT_MESSAGE_FROM_HMODULE = 0x800,
			FORMAT_MESSAGE_FROM_SYSTEM = 0x1000,
			FORMAT_MESSAGE_ARGUMENT_ARRAY = 0x2000
		}

		public enum HitTestResult
		{
			Error = -2,
			Transparent = -1,
			Nowhere = 0,
			Client = 1,
			Caption = 2,
			SysMenu = 3,
			GrowBox = 4,
			Size = 4,
			Menu = 5,
			HScroll = 6,
			VScroll = 7,
			MinButton = 8,
			MaxButton = 9,
			Left = 10,
			Right = 11,
			Top = 12,
			TopLeft = 13,
			TopRight = 14,
			Bottom = 15,
			BottomLeft = 16,
			BottomRight = 17,
			Border = 18,
			Reduce = 8,
			Zoom = 9,
			SizeFirst = 10,
			SizeLast = 17,
			Object = 19,
			Close = 20,
			Help = 21
		}

		public struct MARGINS
		{
			public int Left;

			public int Right;

			public int Top;

			public int Bottom;

			public MARGINS(Padding value)
			{
				Left = ((Padding)(ref value)).Left;
				Right = ((Padding)(ref value)).Right;
				Top = ((Padding)(ref value)).Top;
				Bottom = ((Padding)(ref value)).Bottom;
			}
		}

		public struct DTTOPTS
		{
			public int dwSize;

			[MarshalAs(UnmanagedType.U4)]
			public DrawThemeTextFlags dwFlags;

			public int crText;

			public int crBorder;

			public int crShadow;

			public int iTextShadowType;

			public Point ptShadowOffset;

			public int iBorderSize;

			public int iFontPropId;

			public int iColorPropId;

			public int iStateId;

			public bool fApplyOverlay;

			public int iGlowSize;

			public int pfnDrawTextCallback;

			public IntPtr lParam;
		}

		[Flags]
		public enum DrawThemeTextFlags
		{
			TextColor = 1,
			BorderColor = 2,
			ShadowColor = 4,
			ShadowType = 8,
			ShadowOffset = 0x10,
			BorderSize = 0x20,
			FontProp = 0x40,
			ColorProp = 0x80,
			StateId = 0x100,
			CalcRect = 0x200,
			ApplyOverlay = 0x400,
			GlowSize = 0x800,
			Callback = 0x1000,
			Composited = 0x2000
		}

		[StructLayout(LayoutKind.Sequential)]
		public class BITMAPINFO
		{
			public int biSize;

			public int biWidth;

			public int biHeight;

			public short biPlanes;

			public short biBitCount;

			public int biCompression;

			public int biSizeImage;

			public int biXPelsPerMeter;

			public int biYPelsPerMeter;

			public int biClrUsed;

			public int biClrImportant;

			public byte bmiColors_rgbBlue;

			public byte bmiColors_rgbGreen;

			public byte bmiColors_rgbRed;

			public byte bmiColors_rgbReserved;
		}

		public struct RECT
		{
			public int Left;

			public int Top;

			public int Right;

			public int Bottom;

			public RECT(int left, int top, int right, int bottom)
			{
				Left = left;
				Top = top;
				Right = right;
				Bottom = bottom;
			}

			public RECT(Rectangle rectangle)
			{
				Left = rectangle.X;
				Top = rectangle.Y;
				Right = rectangle.Right;
				Bottom = rectangle.Bottom;
			}

			public override string ToString()
			{
				return "Left: " + Left + ", Top: " + Top + ", Right: " + Right + ", Bottom: " + Bottom;
			}
		}

		[Flags]
		public enum CREDUI_FLAGS
		{
			INCORRECT_PASSWORD = 1,
			DO_NOT_PERSIST = 2,
			REQUEST_ADMINISTRATOR = 4,
			EXCLUDE_CERTIFICATES = 8,
			REQUIRE_CERTIFICATE = 0x10,
			SHOW_SAVE_CHECK_BOX = 0x40,
			ALWAYS_SHOW_UI = 0x80,
			REQUIRE_SMARTCARD = 0x100,
			PASSWORD_ONLY_OK = 0x200,
			VALIDATE_USERNAME = 0x400,
			COMPLETE_USERNAME = 0x800,
			PERSIST = 0x1000,
			SERVER_CREDENTIAL = 0x4000,
			EXPECT_CONFIRMATION = 0x20000,
			GENERIC_CREDENTIALS = 0x40000,
			USERNAME_TARGET_CREDENTIALS = 0x80000,
			KEEP_USERNAME = 0x100000
		}

		[Flags]
		public enum CredUIWinFlags
		{
			Generic = 1,
			Checkbox = 2,
			AutoPackageOnly = 0x10,
			InCredOnly = 0x20,
			EnumerateAdmins = 0x100,
			EnumerateCurrentUser = 0x200,
			SecurePrompt = 0x1000,
			Pack32Wow = 0x10000000
		}

		internal enum CredUIReturnCodes
		{
			NO_ERROR = 0,
			ERROR_CANCELLED = 1223,
			ERROR_NO_SUCH_LOGON_SESSION = 1312,
			ERROR_NOT_FOUND = 1168,
			ERROR_INVALID_ACCOUNT_NAME = 1315,
			ERROR_INSUFFICIENT_BUFFER = 122,
			ERROR_INVALID_PARAMETER = 87,
			ERROR_INVALID_FLAGS = 1004
		}

		internal enum CredTypes
		{
			CRED_TYPE_GENERIC = 1,
			CRED_TYPE_DOMAIN_PASSWORD,
			CRED_TYPE_DOMAIN_CERTIFICATE,
			CRED_TYPE_DOMAIN_VISIBLE_PASSWORD
		}

		internal enum CredPersist
		{
			Session = 1,
			LocalMachine,
			Enterprise
		}

		internal struct CREDUI_INFO
		{
			public int cbSize;

			public IntPtr hwndParent;

			[MarshalAs(UnmanagedType.LPWStr)]
			public string pszMessageText;

			[MarshalAs(UnmanagedType.LPWStr)]
			public string pszCaptionText;

			public IntPtr hbmBanner;
		}

		public struct CREDENTIAL
		{
			public int Flags;

			public CredTypes Type;

			[MarshalAs(UnmanagedType.LPWStr)]
			public string TargetName;

			[MarshalAs(UnmanagedType.LPWStr)]
			public string Comment;

			public long LastWritten;

			public uint CredentialBlobSize;

			public IntPtr CredentialBlob;

			[MarshalAs(UnmanagedType.U4)]
			public CredPersist Persist;

			public int AttributeCount;

			public IntPtr Attributes;

			[MarshalAs(UnmanagedType.LPWStr)]
			public string TargetAlias;

			[MarshalAs(UnmanagedType.LPWStr)]
			public string UserName;
		}

		public const int ErrorFileNotFound = 2;

		public const int WM_USER = 1024;

		public const int WM_GETICON = 127;

		public const int WM_SETICON = 128;

		public const int ICON_SMALL = 0;

		public const int ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID = 4;

		public const int WM_NCHITTEST = 132;

		public const int WM_DWMCOMPOSITIONCHANGED = 798;

		internal const int CREDUI_MAX_USERNAME_LENGTH = 513;

		internal const int CREDUI_MAX_PASSWORD_LENGTH = 256;

		public static bool IsWindowsVistaOrLater
		{
			get
			{
				if (Environment.OSVersion.Platform == PlatformID.Win32NT)
				{
					return Environment.OSVersion.Version >= new Version(6, 0, 6000);
				}
				return false;
			}
		}

		public static bool IsWindowsXPOrLater
		{
			get
			{
				if (Environment.OSVersion.Platform == PlatformID.Win32NT)
				{
					return Environment.OSVersion.Version >= new Version(5, 1, 2600);
				}
				return false;
			}
		}

		[DllImport("kernel32", CharSet = CharSet.Unicode, SetLastError = true)]
		public static extern SafeModuleHandle LoadLibraryEx(string lpFileName, IntPtr hFile, LoadLibraryExFlags dwFlags);

		[DllImport("kernel32", SetLastError = true)]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		[return: MarshalAs(UnmanagedType.Bool)]
		public static extern bool FreeLibrary(IntPtr hModule);

		[DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
		public static extern IntPtr GetActiveWindow();

		[DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
		public static extern bool EnableWindow(IntPtr hwnd, bool bEnable);

		[DllImport("user32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
		public static extern int GetWindowThreadProcessId(IntPtr hWnd, out int lpdwProcessId);

		[DllImport("kernel32.dll", CharSet = CharSet.Auto, ExactSpelling = true)]
		public static extern int GetCurrentThreadId();

		[DllImport("comctl32.dll", PreserveSig = false)]
		public static extern void TaskDialogIndirect([In] ref TASKDIALOGCONFIG pTaskConfig, out int pnButton, out int pnRadioButton, [MarshalAs(UnmanagedType.Bool)] out bool pfVerificationFlagChecked);

		[DllImport("user32.dll", CharSet = CharSet.Auto)]
		public static extern IntPtr SendMessage(IntPtr hwnd, int wMsg, IntPtr wParam, IntPtr lParam);

		[DllImport("Kernel32.dll", SetLastError = true)]
		public static extern ActivationContextSafeHandle CreateActCtx(ref ACTCTX actctx);

		[DllImport("kernel32.dll")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
		public static extern void ReleaseActCtx(IntPtr hActCtx);

		[DllImport("Kernel32.dll", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		public static extern bool ActivateActCtx(ActivationContextSafeHandle hActCtx, out IntPtr lpCookie);

		[DllImport("Kernel32.dll", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		public static extern bool DeactivateActCtx(uint dwFlags, IntPtr lpCookie);

		[DllImport("shell32.dll", CharSet = CharSet.Unicode)]
		public static extern int SHCreateItemFromParsingName([MarshalAs(UnmanagedType.LPWStr)] string pszPath, IntPtr pbc, ref Guid riid, [MarshalAs(UnmanagedType.Interface)] out object ppv);

		public static IShellItem CreateItemFromParsingName(string path)
		{
			Guid riid = new Guid("43826d1e-e718-42ee-bc55-a1e261c37bfe");
			object ppv;
			int num = SHCreateItemFromParsingName(path, IntPtr.Zero, ref riid, out ppv);
			if (num != 0)
			{
				throw new Win32Exception(num);
			}
			return (IShellItem)ppv;
		}

		[DllImport("user32.dll", BestFitMapping = false, CharSet = CharSet.Auto, SetLastError = true, ThrowOnUnmappableChar = true)]
		public static extern int LoadString(SafeModuleHandle hInstance, uint uID, StringBuilder lpBuffer, int nBufferMax);

		[DllImport("Kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
		public static extern uint FormatMessage([MarshalAs(UnmanagedType.U4)] FormatMessageFlags dwFlags, IntPtr lpSource, uint dwMessageId, uint dwLanguageId, ref IntPtr lpBuffer, uint nSize, string[] Arguments);

		[DllImport("dwmapi.dll", PreserveSig = false)]
		public static extern void DwmExtendFrameIntoClientArea(IntPtr hWnd, [In] ref MARGINS pMarInset);

		[DllImport("dwmapi.dll", PreserveSig = false)]
		[return: MarshalAs(UnmanagedType.Bool)]
		public static extern bool DwmIsCompositionEnabled();

		[DllImport("gdi32.dll", ExactSpelling = true, SetLastError = true)]
		public static extern SafeDeviceHandle CreateCompatibleDC(IntPtr hDC);

		[DllImport("gdi32.dll", ExactSpelling = true)]
		public static extern IntPtr SelectObject(SafeDeviceHandle hDC, SafeGDIHandle hObject);

		[DllImport("gdi32.dll", ExactSpelling = true, SetLastError = true)]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		[return: MarshalAs(UnmanagedType.Bool)]
		public static extern bool DeleteObject(IntPtr hObject);

		[DllImport("gdi32.dll", ExactSpelling = true, SetLastError = true)]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		[return: MarshalAs(UnmanagedType.Bool)]
		public static extern bool DeleteDC(IntPtr hdc);

		[DllImport("gdi32.dll")]
		[return: MarshalAs(UnmanagedType.Bool)]
		public static extern bool BitBlt(IntPtr hdc, int nXDest, int nYDest, int nWidth, int nHeight, SafeDeviceHandle hdcSrc, int nXSrc, int nYSrc, uint dwRop);

		[DllImport("UxTheme.dll", CharSet = CharSet.Unicode, PreserveSig = false)]
		public static extern void DrawThemeTextEx(IntPtr hTheme, SafeDeviceHandle hdc, int iPartId, int iStateId, string text, int iCharCount, int dwFlags, ref RECT pRect, ref DTTOPTS pOptions);

		[DllImport("gdi32.dll")]
		public static extern SafeGDIHandle CreateDIBSection(IntPtr hdc, BITMAPINFO pbmi, uint iUsage, IntPtr ppvBits, IntPtr hSection, uint dwOffset);

		[DllImport("UxTheme.dll", CharSet = CharSet.Unicode, PreserveSig = false)]
		public static extern void GetThemeTextExtent(IntPtr hTheme, SafeDeviceHandle hdc, int iPartId, int iStateId, string text, int iCharCount, int dwTextFlags, [In] ref RECT bounds, out RECT rect);

		public static SafeGDIHandle CreateDib(Rectangle bounds, IntPtr primaryHdc, SafeDeviceHandle memoryHdc)
		{
			BITMAPINFO bITMAPINFO = new BITMAPINFO();
			bITMAPINFO.biSize = Marshal.SizeOf(bITMAPINFO);
			bITMAPINFO.biWidth = bounds.Width;
			bITMAPINFO.biHeight = -bounds.Height;
			bITMAPINFO.biPlanes = 1;
			bITMAPINFO.biBitCount = 32;
			bITMAPINFO.biCompression = 0;
			SafeGDIHandle safeGDIHandle = CreateDIBSection(primaryHdc, bITMAPINFO, 0u, IntPtr.Zero, IntPtr.Zero, 0u);
			SelectObject(memoryHdc, safeGDIHandle);
			return safeGDIHandle;
		}

		[DllImport("credui.dll", CharSet = CharSet.Unicode)]
		internal static extern CredUIReturnCodes CredUIPromptForCredentials(ref CREDUI_INFO pUiInfo, string targetName, IntPtr Reserved, int dwAuthError, StringBuilder pszUserName, uint ulUserNameMaxChars, StringBuilder pszPassword, uint ulPaswordMaxChars, [In][Out][MarshalAs(UnmanagedType.Bool)] ref bool pfSave, CREDUI_FLAGS dwFlags);

		[DllImport("credui.dll", CharSet = CharSet.Unicode)]
		public static extern CredUIReturnCodes CredUIPromptForWindowsCredentials(ref CREDUI_INFO pUiInfo, uint dwAuthError, ref uint pulAuthPackage, IntPtr pvInAuthBuffer, uint ulInAuthBufferSize, out IntPtr ppvOutAuthBuffer, out uint pulOutAuthBufferSize, [MarshalAs(UnmanagedType.Bool)] ref bool pfSave, CredUIWinFlags dwFlags);

		[DllImport("advapi32.dll", CharSet = CharSet.Unicode, EntryPoint = "CredReadW", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		internal static extern bool CredRead(string TargetName, CredTypes Type, int Flags, out IntPtr Credential);

		[DllImport("advapi32.dll")]
		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
		internal static extern void CredFree(IntPtr Buffer);

		[DllImport("advapi32.dll", CharSet = CharSet.Unicode, EntryPoint = "CredDeleteW", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		internal static extern bool CredDelete(string TargetName, CredTypes Type, int Flags);

		[DllImport("advapi32.dll", CharSet = CharSet.Unicode, EntryPoint = "CredWriteW", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		internal static extern bool CredWrite(ref CREDENTIAL Credential, int Flags);

		[DllImport("credui.dll", CharSet = CharSet.Unicode, SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		public static extern bool CredPackAuthenticationBuffer(uint dwFlags, string pszUserName, string pszPassword, IntPtr pPackedCredentials, ref uint pcbPackedCredentials);

		[DllImport("credui.dll", CharSet = CharSet.Unicode, SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		public static extern bool CredUnPackAuthenticationBuffer(uint dwFlags, IntPtr pAuthBuffer, uint cbAuthBuffer, StringBuilder pszUserName, ref uint pcchMaxUserName, StringBuilder pszDomainName, ref uint pcchMaxDomainName, StringBuilder pszPassword, ref uint pcchMaxPassword);
	}
	public class OkButtonClickedEventArgs : CancelEventArgs
	{
		private string _input;

		private IWin32Window _inputBoxWindow;

		public string Input => _input;

		public IWin32Window InputBoxWindow => _inputBoxWindow;

		public OkButtonClickedEventArgs(string input, IWin32Window inputBoxWindow)
		{
			_input = input;
			_inputBoxWindow = inputBoxWindow;
		}
	}
	public enum ProgressBarState
	{
		Normal,
		Error,
		Paused
	}
	public enum ProgressBarStyle
	{
		None,
		ProgressBar,
		MarqueeProgressBar
	}
	[DefaultEvent("DoWork")]
	[DefaultProperty("Text")]
	[Description("Represents a dialog that can be used to report progress to the user.")]
	public class ProgressDialog : Component, IProgress<int>, IProgress<string>
	{
		private class ProgressChangedData
		{
			public string Text { get; set; }

			public string Description { get; set; }

			public object UserState { get; set; }
		}

		private string _windowTitle;

		private string _text;

		private string _description;

		private IProgressDialog _dialog;

		private string _cancellationText;

		private bool _useCompactPathsForText;

		private bool _useCompactPathsForDescription;

		private SafeModuleHandle _currentAnimationModuleHandle;

		private bool _cancellationPending;

		private int _percentProgress;

		private IntPtr _ownerHandle;

		private IContainer components;

		private BackgroundWorker _backgroundWorker;

		[Localizable(true)]
		[Category("Appearance")]
		[Description("The text in the progress dialog's title bar.")]
		[DefaultValue("")]
		public string WindowTitle
		{
			get
			{
				return _windowTitle ?? string.Empty;
			}
			set
			{
				_windowTitle = value;
			}
		}

		[Localizable(true)]
		[Category("Appearance")]
		[Description("A short description of the operation being carried out.")]
		public string Text
		{
			get
			{
				return _text ?? string.Empty;
			}
			set
			{
				_text = value;
				if (_dialog != null)
				{
					_dialog.SetLine(1u, Text, UseCompactPathsForText, IntPtr.Zero);
				}
			}
		}

		[Category("Behavior")]
		[Description("Indicates whether path strings in the Text property should be compacted if they are too large to fit on one line.")]
		[DefaultValue(false)]
		public bool UseCompactPathsForText
		{
			get
			{
				return _useCompactPathsForText;
			}
			set
			{
				_useCompactPathsForText = value;
				if (_dialog != null)
				{
					_dialog.SetLine(1u, Text, UseCompactPathsForText, IntPtr.Zero);
				}
			}
		}

		[Localizable(true)]
		[Category("Appearance")]
		[Description("Additional details about the operation being carried out.")]
		[DefaultValue("")]
		public string Description
		{
			get
			{
				return _description ?? string.Empty;
			}
			set
			{
				_description = value;
				if (_dialog != null)
				{
					_dialog.SetLine(2u, Description, UseCompactPathsForDescription, IntPtr.Zero);
				}
			}
		}

		[Category("Behavior")]
		[Description("Indicates whether path strings in the Description property should be compacted if they are too large to fit on one line.")]
		[DefaultValue(false)]
		public bool UseCompactPathsForDescription
		{
			get
			{
				return _useCompactPathsForDescription;
			}
			set
			{
				_useCompactPathsForDescription = value;
				if (_dialog != null)
				{
					_dialog.SetLine(2u, Description, UseCompactPathsForDescription, IntPtr.Zero);
				}
			}
		}

		[Localizable(true)]
		[Category("Appearance")]
		[Description("The text that will be shown after the Cancel button is pressed.")]
		[DefaultValue("")]
		public string CancellationText
		{
			get
			{
				return _cancellationText ?? string.Empty;
			}
			set
			{
				_cancellationText = value;
			}
		}

		[Category("Appearance")]
		[Description("Indicates whether an estimate of the remaining time will be shown.")]
		[DefaultValue(false)]
		public bool ShowTimeRemaining { get; set; }

		[Category("Appearance")]
		[Description("Indicates whether the dialog has a cancel button. Do not set to false unless absolutely necessary.")]
		[DefaultValue(true)]
		public bool ShowCancelButton { get; set; }

		[Category("Window Style")]
		[Description("Indicates whether the progress dialog has a minimize button.")]
		[DefaultValue(true)]
		public bool MinimizeBox { get; set; }

		[Browsable(false)]
		public bool CancellationPending
		{
			get
			{
				_backgroundWorker.ReportProgress(-1);
				return _cancellationPending;
			}
		}

		[Browsable(false)]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
		public AnimationResource Animation { get; set; }

		[Category("Appearance")]
		[Description("Indicates the style of the progress bar.")]
		[DefaultValue(ProgressBarStyle.ProgressBar)]
		public ProgressBarStyle ProgressBarStyle { get; set; }

		[Browsable(false)]
		public bool IsBusy => _backgroundWorker.IsBusy;

		public event DoWorkEventHandler DoWork;

		public event RunWorkerCompletedEventHandler RunWorkerCompleted;

		public event ProgressChangedEventHandler ProgressChanged;

		public ProgressDialog()
			: this(null)
		{
		}

		public ProgressDialog(IContainer container)
		{
			container?.Add(this);
			InitializeComponent();
			ProgressBarStyle = ProgressBarStyle.ProgressBar;
			ShowCancelButton = true;
			MinimizeBox = true;
			if (!NativeMethods.IsWindowsVistaOrLater)
			{
				Animation = AnimationResource.GetShellAnimation(ShellAnimation.FlyingPapers);
			}
		}

		public void Show()
		{
			Show(null);
		}

		public void Show(object argument)
		{
			RunProgressDialog(IntPtr.Zero, argument);
		}

		public void ShowDialog()
		{
			ShowDialog(null, null);
		}

		public void ShowDialog(IWin32Window owner)
		{
			ShowDialog(owner, null);
		}

		public void ShowDialog(IntPtr owner)
		{
			ShowDialog(owner, null);
		}

		public void ShowDialog(IntPtr owner, object argument)
		{
			RunProgressDialog((owner == IntPtr.Zero) ? NativeMethods.GetActiveWindow() : owner, argument);
		}

		public void ShowDialog(IWin32Window owner, object argument)
		{
			RunProgressDialog((owner == null) ? NativeMethods.GetActiveWindow() : owner.Handle, argument);
		}

		void IProgress<int>.Report(int value)
		{
			ReportProgress(value, null, null, null);
		}

		void IProgress<string>.Report(string value)
		{
			ReportProgress(_percentProgress, value, null, null);
		}

		public void ReportProgress(int percentProgress)
		{
			ReportProgress(percentProgress, null, null, null);
		}

		public void ReportProgress(int percentProgress, string text, string description)
		{
			ReportProgress(percentProgress, text, description, null);
		}

		public void ReportProgress(int percentProgress, string text, string description, object userState)
		{
			if (percentProgress < 0 || percentProgress > 100)
			{
				throw new ArgumentOutOfRangeException("percentProgress");
			}
			if (_dialog == null)
			{
				throw new InvalidOperationException(Resources.ProgressDialogNotRunningError);
			}
			_percentProgress = percentProgress;
			_backgroundWorker.ReportProgress(percentProgress, new ProgressChangedData
			{
				Text = text,
				Description = description,
				UserState = userState
			});
		}

		protected virtual void OnDoWork(DoWorkEventArgs e)
		{
			this.DoWork?.Invoke(this, e);
		}

		protected virtual void OnRunWorkerCompleted(RunWorkerCompletedEventArgs e)
		{
			this.RunWorkerCompleted?.Invoke(this, e);
		}

		protected virtual void OnProgressChanged(ProgressChangedEventArgs e)
		{
			this.ProgressChanged?.Invoke(this, e);
		}

		private void RunProgressDialog(IntPtr owner, object argument)
		{
			if (_backgroundWorker.IsBusy)
			{
				throw new InvalidOperationException(Resources.ProgressDialogRunning);
			}
			if (Animation != null)
			{
				try
				{
					_currentAnimationModuleHandle = Animation.LoadLibrary();
				}
				catch (Win32Exception ex)
				{
					throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Resources.AnimationLoadErrorFormat, ex.Message), ex);
				}
				catch (FileNotFoundException ex2)
				{
					throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, Resources.AnimationLoadErrorFormat, ex2.Message), ex2);
				}
			}
			_cancellationPending = false;
			_dialog = (Ookii.Dialogs.WinForms.Interop.ProgressDialog)new ProgressDialogRCW();
			_dialog.SetTitle(WindowTitle);
			if (Animation != null)
			{
				_dialog.SetAnimation(_currentAnimationModuleHandle, (ushort)Animation.ResourceId);
			}
			if (CancellationText.Length > 0)
			{
				_dialog.SetCancelMsg(CancellationText, null);
			}
			_dialog.SetLine(1u, Text, UseCompactPathsForText, IntPtr.Zero);
			_dialog.SetLine(2u, Description, UseCompactPathsForDescription, IntPtr.Zero);
			ProgressDialogFlags progressDialogFlags = ProgressDialogFlags.Normal;
			if (owner != IntPtr.Zero)
			{
				progressDialogFlags |= ProgressDialogFlags.Modal;
			}
			switch (ProgressBarStyle)
			{
			case ProgressBarStyle.None:
				progressDialogFlags |= ProgressDialogFlags.NoProgressBar;
				break;
			case ProgressBarStyle.MarqueeProgressBar:
				progressDialogFlags = ((!NativeMethods.IsWindowsVistaOrLater) ? (progressDialogFlags | ProgressDialogFlags.NoProgressBar) : (progressDialogFlags | ProgressDialogFlags.MarqueeProgress));
				break;
			}
			if (ShowTimeRemaining)
			{
				progressDialogFlags |= ProgressDialogFlags.AutoTime;
			}
			if (!ShowCancelButton)
			{
				progressDialogFlags |= ProgressDialogFlags.NoCancel;
			}
			if (!MinimizeBox)
			{
				progressDialogFlags |= ProgressDialogFlags.NoMinimize;
			}
			_ownerHandle = owner;
			_dialog.StartProgressDialog(owner, null, progressDialogFlags, IntPtr.Zero);
			_backgroundWorker.RunWorkerAsync(argument);
		}

		private void _backgroundWorker_DoWork(object sender, DoWorkEventArgs e)
		{
			OnDoWork(e);
		}

		private void _backgroundWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
		{
			_dialog.StopProgressDialog();
			Marshal.ReleaseComObject(_dialog);
			_dialog = null;
			if (_currentAnimationModuleHandle != null)
			{
				_currentAnimationModuleHandle.Dispose();
				_currentAnimationModuleHandle = null;
			}
			if (_ownerHandle != IntPtr.Zero)
			{
				NativeMethods.EnableWindow(_ownerHandle, bEnable: true);
			}
			OnRunWorkerCompleted(new RunWorkerCompletedEventArgs((!e.Cancelled && e.Error == null) ? e.Result : null, e.Error, e.Cancelled));
		}

		private void _backgroundWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
		{
			_cancellationPending = _dialog.HasUserCancelled();
			if (e.ProgressPercentage < 0 || e.ProgressPercentage > 100)
			{
				return;
			}
			_dialog.SetProgress((uint)e.ProgressPercentage, 100u);
			if (e.UserState is ProgressChangedData progressChangedData)
			{
				if (progressChangedData.Text != null)
				{
					Text = progressChangedData.Text;
				}
				if (progressChangedData.Description != null)
				{
					Description = progressChangedData.Description;
				}
				OnProgressChanged(new ProgressChangedEventArgs(e.ProgressPercentage, progressChangedData.UserState));
			}
		}

		protected override void Dispose(bool disposing)
		{
			try
			{
				if (disposing)
				{
					if (components != null)
					{
						components.Dispose();
					}
					if (_currentAnimationModuleHandle != null)
					{
						_currentAnimationModuleHandle.Dispose();
						_currentAnimationModuleHandle = null;
					}
				}
			}
			finally
			{
				base.Dispose(disposing);
			}
		}

		private void InitializeComponent()
		{
			_backgroundWorker = new BackgroundWorker();
			_backgroundWorker.WorkerReportsProgress = true;
			_backgroundWorker.WorkerSupportsCancellation = true;
			_backgroundWorker.DoWork += _backgroundWorker_DoWork;
			_backgroundWorker.RunWorkerCompleted += _backgroundWorker_RunWorkerCompleted;
			_backgroundWorker.ProgressChanged += _backgroundWorker_ProgressChanged;
		}
	}
	[SecurityPermission(SecurityAction.Demand, UnmanagedCode = true)]
	internal class ActivationContextSafeHandle : SafeHandleZeroOrMinusOneIsInvalid
	{
		public ActivationContextSafeHandle()
			: base(ownsHandle: true)
		{
		}

		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
		protected override bool ReleaseHandle()
		{
			NativeMethods.ReleaseActCtx(handle);
			return true;
		}
	}
	[SecurityPermission(SecurityAction.Demand, UnmanagedCode = true)]
	internal class SafeGDIHandle : SafeHandleZeroOrMinusOneIsInvalid
	{
		internal SafeGDIHandle()
			: base(ownsHandle: true)
		{
		}

		internal SafeGDIHandle(IntPtr existingHandle, bool ownsHandle)
			: base(ownsHandle)
		{
			SetHandle(existingHandle);
		}

		protected override bool ReleaseHandle()
		{
			return NativeMethods.DeleteObject(handle);
		}
	}
	[SecurityPermission(SecurityAction.Demand, UnmanagedCode = true)]
	internal class SafeDeviceHandle : SafeHandleZeroOrMinusOneIsInvalid
	{
		internal SafeDeviceHandle()
			: base(ownsHandle: true)
		{
		}

		internal SafeDeviceHandle(IntPtr existingHandle, bool ownsHandle)
			: base(ownsHandle)
		{
			SetHandle(existingHandle);
		}

		protected override bool ReleaseHandle()
		{
			return NativeMethods.DeleteDC(handle);
		}
	}
	internal class SafeModuleHandle : SafeHandle
	{
		public override bool IsInvalid => handle == IntPtr.Zero;

		public SafeModuleHandle()
			: base(IntPtr.Zero, ownsHandle: true)
		{
		}

		[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
		protected override bool ReleaseHandle()
		{
			return NativeMethods.FreeLibrary(handle);
		}
	}
	public enum ShellAnimation
	{
		FileMove = 160,
		FileCopy = 161,
		FlyingPapers = 165,
		SearchGlobe = 166,
		PermanentDelete = 164,
		FromRecycleBinDelete = 163,
		ToRecycleBinDelete = 162,
		SearchComputer = 152,
		SearchDocument = 151,
		SearchFlashlight = 150
	}
	[DefaultProperty("MainInstruction")]
	[DefaultEvent("ButtonClicked")]
	[Description("Displays a task dialog.")]
	[Designer(typeof(TaskDialogDesigner))]
	public class TaskDialog : Component, IWin32Window
	{
		private TaskDialogItemCollection<TaskDialogButton> _buttons;

		private TaskDialogItemCollection<TaskDialogRadioButton> _radioButtons;

		private NativeMethods.TASKDIALOGCONFIG _config;

		private TaskDialogIcon _mainIcon;

		private Icon _customMainIcon;

		private Icon _customFooterIcon;

		private TaskDialogIcon _footerIcon;

		private Dictionary<int, TaskDialogButton> _buttonsById;

		private Dictionary<int, TaskDialogRadioButton> _radioButtonsById;

		private IntPtr _handle;

		private int _progressBarMarqueeAnimationSpeed = 100;

		private int _progressBarMinimimum;

		private int _progressBarMaximum = 100;

		private int _progressBarValue;

		private ProgressBarState _progressBarState;

		private int _inEventHandler;

		private bool _updatePending;

		private object _tag;

		private Icon _windowIcon;

		private IContainer components;

		public static bool OSSupportsTaskDialogs => NativeMethods.IsWindowsVistaOrLater;

		[Localizable(true)]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[Category("Appearance")]
		[Description("A list of the buttons on the Task Dialog.")]
		public TaskDialogItemCollection<TaskDialogButton> Buttons => _buttons ?? (_buttons = new TaskDialogItemCollection<TaskDialogButton>(this));

		[Localizable(true)]
		[DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
		[Category("Appearance")]
		[Description("A list of the radio buttons on the Task Dialog.")]
		public TaskDialogItemCollection<TaskDialogRadioButton> RadioButtons => _radioButtons ?? (_radioButtons = new TaskDialogItemCollection<TaskDialogRadioButton>(this));

		[Localizable(true)]
		[Category("Appearance")]
		[Description("The window title of the task dialog.")]
		[DefaultValue("")]
		public string WindowTitle
		{
			get
			{
				return _config.pszWindowTitle ?? string.Empty;
			}
			set
			{
				_config.pszWindowTitle = (string.IsNullOrEmpty(value) ? null : value);
				UpdateDialog();
			}
		}

		[Localizable(true)]
		[Category("Appearance")]
		[Description("The dialog's main instruction.")]
		[DefaultValue("")]
		[Editor(typeof(MultilineStringEditor), typeof(UITypeEditor))]
		public string MainInstruction
		{
			get
			{
				return _config.pszMainInstruction ?? string.Empty;
			}
			set
			{
				_config.pszMainInstruction = (string.IsNullOrEmpty(value) ? null : value);
				SetElementText(NativeMethods.TaskDialogElements.MainInstruction, MainInstruction);
			}
		}

		[Localizable(true)]
		[Category("Appearance")]
		[Description("The dialog's primary content.")]
		[DefaultValue("")]
		[Editor(typeof(MultilineStringEditor), typeof(UITypeEditor))]
		public string Content
		{
			get
			{
				return _config.pszContent ?? string.Empty;
			}
			set
			{
				_config.pszContent = (string.IsNullOrEmpty(value) ? null : value);
				SetElementText(NativeMethods.TaskDialogElements.Content, Content);
			}
		}

		[Localizable(true)]
		[Category("Appearance")]
		[Description("The icon to be used in the title bar of the dialog. Used only when the dialog is shown as a modeless dialog.")]
		[DefaultValue(null)]
		public Icon WindowIcon
		{
			get
			{
				if (IsDialogRunning)
				{
					return Icon.FromHandle(NativeMethods.SendMessage(Handle, 127, new IntPtr(0), IntPtr.Zero));
				}
				return _windowIcon;
			}
			set
			{
				_windowIcon = value;
			}
		}

		[Localizable(true)]
		[Category("Appearance")]
		[Description("The icon to display in the task dialog.")]
		[DefaultValue(TaskDialogIcon.Custom)]
		public TaskDialogIcon MainIcon
		{
			get
			{
				return _mainIcon;
			}
			set
			{
				if (_mainIcon != value)
				{
					_mainIcon = value;
					UpdateDialog();
				}
			}
		}

		[Localizable(true)]
		[Category("Appearance")]
		[Description("A custom icon to display in the dialog.")]
		[DefaultValue(null)]
		public Icon CustomMainIcon
		{
			get
			{
				return _customMainIcon;
			}
			set
			{
				if (_customMainIcon != value)
				{
					_customMainIcon = value;
					UpdateDialog();
				}
			}
		}

		[Localizable(true)]
		[Category("Appearance")]
		[Description("The icon to display in the footer area of the task dialog.")]
		[DefaultValue(TaskDialogIcon.Custom)]
		public TaskDialogIcon FooterIcon
		{
			get
			{
				return _footerIcon;
			}
			set
			{
				if (_footerIcon != value)
				{
					_footerIcon = value;
					UpdateDialog();
				}
			}
		}

		[Localizable(true)]
		[Category("Appearance")]
		[Description("A custom icon to display in the footer area of the task dialog.")]
		[DefaultValue(null)]
		public Icon CustomFooterIcon
		{
			get
			{
				return _customFooterIcon;
			}
			set
			{
				if (_customFooterIcon != value)
				{
					_customFooterIcon = value;
					UpdateDialog();
				}
			}
		}

		[Category("Behavior")]
		[Description("Indicates whether custom buttons should be displayed as normal buttons or command links.")]
		[DefaultValue(TaskDialogButtonStyle.Standard)]
		public TaskDialogButtonStyle ButtonStyle
		{
			get
			{
				if (!GetFlag(NativeMethods.TaskDialogFlags.UseCommandLinksNoIcon))
				{
					if (!GetFlag(NativeMethods.TaskDialogFlags.UseCommandLinks))
					{
						return TaskDialogButtonStyle.Standard;
					}
					return TaskDialogButtonStyle.CommandLinks;
				}
				return TaskDialogButtonStyle.CommandLinksNoIcon;
			}
			set
			{
				SetFlag(NativeMethods.TaskDialogFlags.UseCommandLinks, value == TaskDialogButtonStyle.CommandLinks);
				SetFlag(NativeMethods.TaskDialogFlags.UseCommandLinksNoIcon, value == TaskDialogButtonStyle.CommandLinksNoIcon);
				UpdateDialog();
			}
		}

		[Localizable(true)]
		[Category("Appearance")]
		[Description("The label for the verification checkbox.")]
		[DefaultValue("")]
		public string VerificationText
		{
			get
			{
				return _config.pszVerificationText ?? string.Empty;
			}
			set
			{
				string text = (string.IsNullOrEmpty(value) ? null : value);
				if (_config.pszVerificationText != text)
				{
					_config.pszVerificationText = text;
					UpdateDialog();
				}
			}
		}

		[Category("Behavior")]
		[Description("Indicates whether the verification checkbox is checked ot not.")]
		[DefaultValue(false)]
		public bool IsVerificationChecked
		{
			get
			{
				return GetFlag(NativeMethods.TaskDialogFlags.VerificationFlagChecked);
			}
			set
			{
				if (value != IsVerificationChecked)
				{
					SetFlag(NativeMethods.TaskDialogFlags.VerificationFlagChecked, value);
					if (IsDialogRunning)
					{
						ClickVerification(value, setFocus: false);
					}
				}
			}
		}

		[Localizable(true)]
		[Category("Appearance")]
		[Description("Additional information to be displayed on the dialog.")]
		[DefaultValue("")]
		[Editor(typeof(MultilineStringEditor), typeof(UITypeEditor))]
		public string ExpandedInformation
		{
			get
			{
				return _config.pszExpandedInformation ?? string.Empty;
			}
			set
			{
				_config.pszExpandedInformation = (string.IsNullOrEmpty(value) ? null : value);
				SetElementText(NativeMethods.TaskDialogElements.ExpandedInformation, ExpandedInformation);
			}
		}

		[Localizable(true)]
		[Category("Appearance")]
		[Description("The text to use for the control for collapsing the expandable information.")]
		[DefaultValue("")]
		public string ExpandedControlText
		{
			get
			{
				return _config.pszExpandedControlText ?? string.Empty;
			}
			set
			{
				string text = (string.IsNullOrEmpty(value) ? null : value);
				if (_config.pszExpandedControlText != text)
				{
					_config.pszExpandedControlText = text;
					UpdateDialog();
				}
			}
		}

		[Localizable(true)]
		[Category("Appearance")]
		[Description("The text to use for the control for expanding the expandable information.")]
		[DefaultValue("")]
		public string CollapsedControlText
		{
			get
			{
				return _config.pszCollapsedControlText ?? string.Empty;
			}
			set
			{
				string text = (string.IsNullOrEmpty(value) ? null : value);
				if (_config.pszCollapsedControlText != text)
				{
					_config.pszCollapsedControlText = (string.IsNullOrEmpty(value) ? null : value);
					UpdateDialog();
				}
			}
		}

		[Localizable(true)]
		[Category("Appearance")]
		[Description("The text to be used in the footer area of the task dialog.")]
		[DefaultValue("")]
		[Editor(typeof(MultilineStringEditor), typeof(UITypeEditor))]
		public string Footer
		{
			get
			{
				return _config.pszFooterText ?? string.Empty;
			}
			set
			{
				_config.pszFooterText = (string.IsNullOrEmpty(value) ? null : value);
				SetElementText(NativeMethods.TaskDialogElements.Footer, Footer);
			}
		}

		[Localizable(true)]
		[Category("Appearance")]
		[Description("the width of the task d